Реализация операторов C++

Введение

В этом лабораторном занятии вы научитесь реализовывать различные операторы языка C++, включая базовые математические операции, инкремент/декремент, отношения и логические операторы, битовые операции, составные операции присваивания, порядок выполнения операций и тернарный условный оператор. Эти фундаментальные операторы являются важными для выполнения арифметических операций, сравнений и манипуляций данными в программировании на C++. С помощью серии практических упражнений вы получите твердое понимание того, как эффективно использовать эти операторы для создания более сложных и эффективных приложений на C++.

Skills Graph

Выполнение базовых математических операций (+, -, *, /, %)

В этом шаге вы научитесь выполнять базовые математические операции на языке C++. Математические операции являются фундаментальными для программирования и позволяют манипулировать числовыми значениями с использованием стандартных арифметических операторов.

Откройте WebIDE и создайте новый файл с именем math_operations.cpp в директории ~/project:

touch ~/project/math_operations.cpp

Добавьте следующий код в файл math_operations.cpp:

#include <iostream>

int main() {
    // Declare variables for mathematical operations
    int a = 10;
    int b = 3;

    // Addition (+)
    int sum = a + b;
    std::cout << "Addition: " << a << " + " << b << " = " << sum << std::endl;

    // Subtraction (-)
    int difference = a - b;
    std::cout << "Subtraction: " << a << " - " << b << " = " << difference << std::endl;

    // Multiplication (*)
    int product = a * b;
    std::cout << "Multiplication: " << a << " * " << b << " = " << product << std::endl;

    // Division (/)
    int quotient = a / b;
    std::cout << "Division: " << a << " / " << b << " = " << quotient << std::endl;

    // Modulus (%) - Remainder of division
    int remainder = a % b;
    std::cout << "Modulus: " << a << " % " << b << " = " << remainder << std::endl;

    return 0;
}

Скомпилируйте и запустите программу:

g++ math_operations.cpp -o math_operations
./math_operations

Пример вывода:

Addition: 10 + 3 = 13
Subtraction: 10 - 3 = 7
Multiplication: 10 * 3 = 30
Division: 10 / 3 = 3
Modulus: 10 % 3 = 1

Разберем математические операторы:

1. + (Сложение): Складывает два числа. Например, 5 + 3 даст результат 8.
2. - (Вычитание): Вычитает второе число из первого. Например, 10 - 4 даст результат 6.
3. * (Умножение): Умножает два числа. Например, 6 * 7 даст результат 42.
4. / (Деление): Делит первое число на второе. Когда оба числа являются целыми, это приводит к целочисленному делению, то есть дробная часть отбрасывается. Например, 10 / 3 даст результат 3.
5. % (Остаток от деления): Возвращает остаток от деления. Например, 10 % 3 даст результат 1, так как остаток от деления 10 на 3 равен 1.

Некоторые важные замечания:

• Целочисленное деление отбрасывает дробную часть. Например, 5 / 2 даст результат 2, а не 2.5.
• Оператор остатка от деления работает только с целочисленными типами. Его нельзя использовать с числами с плавающей точкой (например, float или double).
• Будьте всегда осторожны при делении на ноль, которое вызывает ошибки во время выполнения. Ваша программа аварийно завершится, если вы попытаетесь разделить любое число на ноль.

Использование префиксного и постфиксного инкремента/декремента (++i, i++)

В этом шаге вы узнаете о операторах инкремента и декремента в языке C++. Эти операторы позволяют увеличивать или уменьшать значение переменной на 1, причем между префиксным и постфиксным инкрементом есть незначительные различия.

Откройте WebIDE и создайте новый файл с именем increment_decrement.cpp в директории ~/project:

touch ~/project/increment_decrement.cpp

Добавьте следующий код в файл increment_decrement.cpp:

#include <iostream>

int main() {
    // Pre-increment (++i)
    int a = 5;
    std::cout << "Original value of a: " << a << std::endl;

    // Pre-increment: increment happens before the value is used
    std::cout << "Pre-increment (++a): " << ++a << std::endl;
    std::cout << "Value after pre-increment: " << a << std::endl;

    // Post-increment (i++)
    int b = 5;
    std::cout << "\nOriginal value of b: " << b << std::endl;

    // Post-increment: increment happens after the value is used
    std::cout << "Post-increment (b++): " << b++ << std::endl;
    std::cout << "Value after post-increment: " << b << std::endl;

    // Decrement operators work similarly
    int c = 5;
    std::cout << "\nPre-decrement (--c): " << --c << std::endl;

    int d = 5;
    std::cout << "Post-decrement (d--): " << d-- << std::endl;
    std::cout << "Value after post-decrement: " << d << std::endl;

    return 0;
}

Скомпилируйте и запустите программу:

g++ increment_decrement.cpp -o increment_decrement
./increment_decrement

Пример вывода:

Original value of a: 5
Pre-increment (++a): 6
Value after pre-increment: 6

Original value of b: 5
Post-increment (b++): 5
Value after post-increment: 6

Pre-decrement (--c): 4
Post-decrement (d--): 5
Value after post-decrement: 4

Основные различия:

• Префиксный инкремент ++i: Увеличивает значение до его использования в выражении. В примере кода ++a сначала увеличивает a до 6, а затем значение 6 используется в инструкции cout.
• Постфиксный инкремент i++: Сначала использует текущее значение в выражении, а затем увеличивает значение. В примере кода b++ сначала использует текущее значение b, которое равно 5, в инструкции cout, а затем увеличивает b до 6.

Те же принципы применяются к операторам декремента --i и i--, где --i сначала уменьшает значение, а затем использует его, а i-- сначала использует значение, а затем уменьшает его.

Важные замечания:

• Префиксный инкремент изменяет значение до его использования в выражении, то есть увеличенное значение сразу же доступно для использования.
• Постфиксный инкремент сначала использует исходное значение, а затем увеличивает его. Это означает, что в текущей инструкции вы получаете исходное значение, а в следующей — увеличенное.
• Эти операторы обычно используются в циклах (например, в циклах for) и сложных выражениях, где вы хотите изменить переменную, используя одновременно ее значение.
• При использовании этих операторов, особенно в сложных выражениях, важно помнить, нужна ли вам префиксная или постфиксная версия, чтобы получить желаемое поведение.

Сравнение значений с использованием операторов сравнения (<, >, ==,!=)

В этом шаге вы узнаете о операторах сравнения в языке C++. Эти операторы помогают сравнивать значения и определять отношения между разными числами или переменными.

Откройте WebIDE и создайте новый файл с именем relational_operators.cpp в директории ~/project:

touch ~/project/relational_operators.cpp

Добавьте следующий код в файл relational_operators.cpp:

#include <iostream>

int main() {
    int a = 10;
    int b = 5;
    int c = 10;

    // Less than (<)
    std::cout << "Less than (<):" << std::endl;
    std::cout << a << " < " << b << " is " << (a < b) << std::endl;
    std::cout << b << " < " << a << " is " << (b < a) << std::endl;

    // Greater than (>)
    std::cout << "\nGreater than (>):" << std::endl;
    std::cout << a << " > " << b << " is " << (a > b) << std::endl;
    std::cout << b << " > " << a << " is " << (b > a) << std::endl;

    // Equal to (==)
    std::cout << "\nEqual to (==):" << std::endl;
    std::cout << a << " == " << b << " is " << (a == b) << std::endl;
    std::cout << a << " == " << c << " is " << (a == c) << std::endl;

    // Not equal to (!=)
    std::cout << "\nNot equal to (!=):" << std::endl;
    std::cout << a << "!= " << b << " is " << (a!= b) << std::endl;
    std::cout << a << "!= " << c << " is " << (a!= c) << std::endl;

    return 0;
}

Скомпилируйте и запустите программу:

g++ relational_operators.cpp -o relational_operators
./relational_operators

Пример вывода:

Less than (<):
10 < 5 is 0
5 < 10 is 1

Greater than (>):
10 > 5 is 1
5 > 10 is 0

Equal to (==):
10 == 5 is 0
10 == 10 is 1

Not equal to (!=):
10!= 5 is 1
10!= 10 is 0

Основные моменты о операторах сравнения:

• < (Меньше): Проверяет, является ли левое значение меньше правого. Например, 5 < 10 истинно (возвращает 1), а 10 < 5 ложно (возвращает 0).
• > (Больше): Проверяет, является ли левое значение больше правого. Например, 10 > 5 истинно (возвращает 1), а 5 > 10 ложно (возвращает 0).
• == (Равно): Проверяет, равны ли два значения. Например, 5 == 5 истинно (возвращает 1), а 5 == 6 ложно (возвращает 0).
• != (Не равно): Проверяет, не равны ли два значения. Например, 5!= 6 истинно (возвращает 1), а 5!= 5 ложно (возвращает 0).
• Эти операторы возвращают 1 (истина) или 0 (ложь). В C++ 1 представляет истину, а 0 — ложь. Эти значения можно использовать в условных инструкциях.

Важные замечания:

• Операторы сравнения являются фундаментальными для создания условных инструкций, позволяя вашей программе принимать решения на основе сравнений.
• Они всегда возвращают булево значение, которое в C++ представлено целым числом (1 для истины, 0 для ложь).
• Эти операторы обычно используются в инструкциях if, циклах while и циклах for для управления потоком выполнения.

Комбинирование условий с использованием логических операторов И (&&) и ИЛИ (||)

В этом шаге вы научитесь комбинировать несколько условий с использованием логических операторов И (&&) и ИЛИ (||) в языке C++. Эти операторы помогают создавать более сложные условные инструкции, оценивая несколько условий одновременно.

Откройте WebIDE и создайте новый файл с именем logical_operators.cpp в директории ~/project:

touch ~/project/logical_operators.cpp

Добавьте следующий код в файл logical_operators.cpp:

#include <iostream>

int main() {
    int x = 10;
    int y = 5;
    int z = 15;

    // Logical AND (&&) operator
    std::cout << "Logical AND (&&) operator:" << std::endl;

    // Both conditions must be true
    if (x > y && x < z) {
        std::cout << "x is greater than y AND less than z" << std::endl;
    }

    if (x > 20 && y < 10) {
        std::cout << "This will not be printed" << std::endl;
    }

    // Logical OR (||) operator
    std::cout << "\nLogical OR (||) operator:" << std::endl;

    // At least one condition must be true
    if (x > 20 || y < 10) {
        std::cout << "At least one condition is true" << std::endl;
    }

    if (x > 20 || z < 20) {
        std::cout << "Another true condition" << std::endl;
    }

    // Combining AND and OR
    std::cout << "\nCombining AND and OR:" << std::endl;

    if ((x > y && y < z) || x == 10) {
        std::cout << "Complex condition is true" << std::endl;
    }

    return 0;
}

Скомпилируйте и запустите программу:

g++ logical_operators.cpp -o logical_operators
./logical_operators

Пример вывода:

Logical AND (&&) operator:
x is greater than y AND less than z

Logical OR (||) operator:
At least one condition is true
Another true condition

Combining AND and OR:
Complex condition is true

Основные моменты о логических операторах:

• && (И): Оба условия, соединенные оператором &&, должны быть истинными, чтобы вся выражение было истинным. Если хотя бы одно из условий ложно, то вся выражение оценивается как ложное. В коде x > y && x < z истинно, потому что x > y (10 > 5) и x < z (10 < 15) оба истинны.
• || (ИЛИ): Хотя бы одно из условий, соединенных оператором ||, должно быть истинным, чтобы вся выражение было истинным. Если все условия ложны, то вся выражение оценивается как ложное. В коде x > 20 || y < 10 истинно, потому что y < 10 (5 < 10) истинно.
• Вы можете комбинировать несколько условий с использованием скобок, чтобы контролировать порядок вычислений. Это делает сложные выражения легче для чтения и понимания.
• Эти операторы чрезвычайно полезны для создания сложной логики принятия решений в условных инструкциях.

Важные замечания:

• Логические операторы часто используются в инструкциях if, циклах while и других структурах управления потоком выполнения, чтобы сделать программы более гибкими.
• Они помогают создавать более сложные условные проверки, позволяя проверять несколько критериев одновременно.
• Краткое-circuit evaluation (короткое вычисление):
  • Для &&, если первое условие ложно, то второе условие не вычисляется, потому что вся выражение будет ложным независимо от значения второго условия. Эта оптимизация может повысить производительность.
  • Для ||, если первое условие истинно, то второе условие не вычисляется, потому что вся выражение будет истинным.

Применение побитовых операций для манипуляции с двоичными данными

В этом шаге вы узнаете о побитовых операторах в языке C++. Эти операторы работают непосредственно с двоичным представлением целых чисел, позволяя манипулировать отдельными битами.

Откройте WebIDE и создайте новый файл с именем bitwise_operations.cpp в директории ~/project:

touch ~/project/bitwise_operations.cpp

Добавьте следующий код в файл bitwise_operations.cpp:

#include <iostream>
#include <bitset>

int main() {
    // Binary representation of numbers
    unsigned int a = 5;   // 0101 in binary
    unsigned int b = 3;   // 0011 in binary

    // Bitwise AND (&)
    std::cout << "Bitwise AND (&):" << std::endl;
    std::cout << "a = " << std::bitset<4>(a) << " (5 in decimal)" << std::endl;
    std::cout << "b = " << std::bitset<4>(b) << " (3 in decimal)" << std::endl;
    unsigned int and_result = a & b;
    std::cout << "a & b = " << std::bitset<4>(and_result)
              << " (" << and_result << " in decimal)" << std::endl;

    // Bitwise OR (|)
    std::cout << "\nBitwise OR (|):" << std::endl;
    unsigned int or_result = a | b;
    std::cout << "a | b = " << std::bitset<4>(or_result)
              << " (" << or_result << " in decimal)" << std::endl;

    // Bitwise XOR (^)
    std::cout << "\nBitwise XOR (^):" << std::endl;
    unsigned int xor_result = a ^ b;
    std::cout << "a ^ b = " << std::bitset<4>(xor_result)
              << " (" << xor_result << " in decimal)" << std::endl;

    // Bitwise NOT (~)
    std::cout << "\nBitwise NOT (~):" << std::endl;
    unsigned int not_result = ~a;
    std::cout << "~a = " << std::bitset<32>(not_result)
              << " (" << not_result << " in decimal)" << std::endl;

    // Left shift (<<)
    std::cout << "\nLeft Shift (<<):" << std::endl;
    unsigned int left_shift = a << 2;
    std::cout << "a << 2 = " << std::bitset<8>(left_shift)
              << " (" << left_shift << " in decimal)" << std::endl;

    // Right shift (>>)
    std::cout << "\nRight Shift (>>):" << std::endl;
    unsigned int right_shift = a >> 1;
    std::cout << "a >> 1 = " << std::bitset<4>(right_shift)
              << " (" << right_shift << " in decimal)" << std::endl;

    return 0;
}

Скомпилируйте и запустите программу:

g++ bitwise_operations.cpp -o bitwise_operations
./bitwise_operations

Пример вывода:

Bitwise AND (&):
a = 0101 (5 in decimal)
b = 0011 (3 in decimal)
a & b = 0001 (1 in decimal)

Bitwise OR (|):
a | b = 0111 (7 in decimal)

Bitwise XOR (^):
a ^ b = 0110 (6 in decimal)

Bitwise NOT (~):
~a = 11111111111111111111111111111010 (4294967290 in decimal)

Left Shift (<<):
a << 2 = 00010100 (20 in decimal)

Right Shift (>>):
a >> 1 = 0010 (2 in decimal)

Основные моменты о побитовых операторах:

• & (Побитовое И): Сравнивает соответствующие биты двух чисел. Если оба бита равны 1, то результирующий бит равен 1; в противном случае он равен 0. В примере кода 5 & 3 (двоичное 0101 & 0011) дает результат 0001, что в десятичной системе равно 1.
• | (Побитовое ИЛИ): Сравнивает соответствующие биты двух чисел. Если хотя бы один из битов равен 1, то результирующий бит равен 1; в противном случае он равен 0. В примере 5 | 3 (двоичное 0101 | 0011) дает результат 0111, что в десятичной системе равно 7.
• ^ (Побитовое исключающее ИЛИ): Сравнивает соответствующие биты двух чисел. Если биты различны, то результирующий бит равен 1; в противном случае он равен 0. В примере 5 ^ 3 (двоичное 0101 ^ 0011) дает результат 0110, что в десятичной системе равно 6.
• ~ (Побитовое НЕ): Инвертирует все биты числа. Если бит равен 1, он становится 0, и наоборот. Обратите внимание, что результат ~a равен 11111111111111111111111111111010, что является двоичным представлением результата, когда число рассматривается как 32 - битное беззнаковое целое число.
• << (Сдвиг влево): Сдвигает биты числа влево на указанное количество позиций. Это эквивалентно умножению числа на 2 при каждом сдвиге. В примере 5 << 2 (двоичное 0101 << 2) сдвигает биты так, чтобы получилось 010100, что в десятичной системе равно 20.
• >> (Сдвиг вправо): Сдвигает биты числа вправо на указанное количество позиций. Это эквивалентно делению числа на 2 при каждом сдвиге. В примере 5 >> 1 (двоичное 0101 >> 1) сдвигает биты так, чтобы получилось 0010, что в десятичной системе равно 2.

Важные замечания:

• Побитовые операции работают непосредственно с двоичным представлением целых чисел, позволяя проводить низкоуровневую манипуляцию и оптимизацию.
• Они обычно используются в встроенных системах, программировании графики и в сценариях, где необходимо устанавливать, очищать или проверять отдельные биты в значении.
• Будьте осторожны при работе с знаковыми и беззнаковыми целыми числами, так как поведение сдвига вправо может различаться (арифметический и логический сдвиг).
• Использование std::bitset помогает визуализировать, как эти операции работают на битовом уровне.

Использование составных операторов присваивания (+=, -=, *=)

В этом шаге вы узнаете о составных операторах присваивания в языке C++. Эти операторы объединяют арифметическую операцию с присваиванием, делая ваш код более компактным и читаемым.

Откройте WebIDE и создайте новый файл с именем compound_operators.cpp в директории ~/project:

touch ~/project/compound_operators.cpp

Добавьте следующий код в файл compound_operators.cpp:

#include <iostream>

int main() {
    // Initialize variables
    int x = 10;
    int y = 5;

    // Addition assignment (+=)
    std::cout << "Addition Assignment (+=):" << std::endl;
    std::cout << "Initial x: " << x << std::endl;
    x += 3;  // Equivalent to x = x + 3
    std::cout << "x += 3: " << x << std::endl;

    // Subtraction assignment (-=)
    std::cout << "\nSubtraction Assignment (-=):" << std::endl;
    std::cout << "Initial y: " << y << std::endl;
    y -= 2;  // Equivalent to y = y - 2
    std::cout << "y -= 2: " << y << std::endl;

    // Multiplication assignment (*=)
    std::cout << "\nMultiplication Assignment (*=):" << std::endl;
    int z = 4;
    std::cout << "Initial z: " << z << std::endl;
    z *= 3;  // Equivalent to z = z * 3
    std::cout << "z *= 3: " << z << std::endl;

    // Division assignment (/=)
    std::cout << "\nDivision Assignment (/=):" << std::endl;
    int a = 15;
    std::cout << "Initial a: " << a << std::endl;
    a /= 3;  // Equivalent to a = a / 3
    std::cout << "a /= 3: " << a << std::endl;

    // Modulus assignment (%=)
    std::cout << "\nModulus Assignment (%=):" << std::endl;
    int b = 17;
    std::cout << "Initial b: " << b << std::endl;
    b %= 5;  // Equivalent to b = b % 5
    std::cout << "b %= 5: " << b << std::endl;

    return 0;
}

Скомпилируйте и запустите программу:

g++ compound_operators.cpp -o compound_operators
./compound_operators

Пример вывода:

Addition Assignment (+=):
Initial x: 10
x += 3: 13

Subtraction Assignment (-=):
Initial y: 5
y -= 2: 3

Multiplication Assignment (*=):
Initial z: 4
z *= 3: 12

Division Assignment (/=):
Initial a: 15
a /= 3: 5

Modulus Assignment (%=):
Initial b: 17
b %= 5: 2

Основные моменты о составных операторах присваивания:

• += (Прибавить и присвоить): Прибавляет правый операнд к левому операнду и присваивает результат левому операнду. x += 3 эквивалентно x = x + 3.
• -= (Вычесть и присвоить): Вычитает правый операнд из левого операнда и присваивает результат левому операнду. y -= 2 эквивалентно y = y - 2.
• *= (Умножить и присвоить): Умножает левый операнд на правый операнд и присваивает результат левому операнду. z *= 3 эквивалентно z = z * 3.
• /= (Разделить и присвоить): Делит левый операнд на правый операнд и присваивает результат левому операнду. a /= 3 эквивалентно a = a / 3.
• %= (Остаток от деления и присвоить): Вычисляет остаток от деления левого операнда на правый операнд и присваивает результат левому операнду. b %= 5 эквивалентно b = b % 5.

Важные замечания:

• Составные операторы присваивания делают ваш код более компактным и легким для чтения, объединяя операцию и присваивание в один шаг.
• Они работают со всеми основными арифметическими операциями (+, -, *, /, %).
• Они могут помочь сократить количество набираемых символов, сделать код короче и, возможно, повысить производительность.

Понимание порядка выполнения операций с несколькими операторами

В этом шаге вы узнаете о порядке выполнения операций в языке C++, который часто запоминается по акрониму PEMDAS (скобки, степени, умножение и деление, сложение и вычитание). Понимание этого порядка является важным для написания правильных математических выражений.

Откройте WebIDE и создайте новый файл с именем order_of_operations.cpp в директории ~/project:

touch ~/project/order_of_operations.cpp

Добавьте следующий код в файл order_of_operations.cpp:

#include <iostream>

int main() {
    // Basic order of operations demonstration
    int a = 10;
    int b = 5;
    int c = 3;

    // Multiplication before addition
    std::cout << "Multiplication before Addition:" << std::endl;
    int result1 = a + b * c;
    std::cout << "a + b * c = " << result1 << std::endl;

    // Parentheses change the order of operations
    std::cout << "\nParentheses change order:" << std::endl;
    int result2 = (a + b) * c;
    std::cout << "(a + b) * c = " << result2 << std::endl;

    // Complex expression with multiple operators
    std::cout << "\nComplex Expression:" << std::endl;
    int x = 4;
    int y = 2;
    int z = 3;

    int complex_result = x + y * z - (x / y);
    std::cout << "x + y * z - (x / y) = " << complex_result << std::endl;

    // Demonstrating precedence with increment and multiplication
    std::cout << "\nIncrement and Multiplication:" << std::endl;
    int m = 3;
    int n = 2;
    int precedence_result = m++ * n;
    std::cout << "m++ * n = " << precedence_result << std::endl;
    std::cout << "m after operation = " << m << std::endl;

    return 0;
}

Скомпилируйте и запустите программу:

g++ order_of_operations.cpp -o order_of_operations
./order_of_operations

Пример вывода:

Multiplication before Addition:
a + b * c = 25

Parentheses change order:
(a + b) * c = 45

Complex Expression:
x + y * z - (x / y) = 8

Increment and Multiplication:
m++ * n = 6
m after operation = 4

Основные моменты о порядке выполнения операций:

• Порядок выполнения операций, также известный как приоритет операторов, определяет, как выражение будет вычисляться. C++ следует правилам математики в этом вопросе.
• PEMDAS/BODMAS: Это распространенная запоминающая фраза для запоминания порядка:
  • Parentheses / Brackets (скобки): Выражения в скобках вычисляются сначала.
  • Exponents / Orders (степени): Степени или операции (например, квадратные корни) вычисляются следующими, хотя в C++ нет встроенного оператора для возведения в степень, этот шаг относится к функциям типа pow().
  • MD (умножение и деление): Умножение и деление имеют одинаковый приоритет и вычисляются слева направо.
  • AS (сложение и вычитание): Сложение и вычитание имеют одинаковый приоритет и вычисляются слева направо.
• В коде int result1 = a + b * c; вычисляется как 10 + (5 * 3), что равно 10 + 15 = 25, так как умножение имеет более высокий приоритет, чем сложение.
• Скобки могут изменить стандартный порядок выполнения операций, поэтому выражение int result2 = (a + b) * c; вычисляется как (10 + 5) * 3, что равно 15 * 3 = 45, так как выражение в скобках вычисляется сначала.
• Операторы инкремента/декремента имеют специальные правила приоритета, которые иногда могут быть запутанными. В коде использован пост - инкрементный оператор m++, при этом первоначальное значение m сначала используется в умножении m * n, а только потом переменная m инкрементируется.
• В сложном выражении x + y * z - (x / y) умножение и деление выполняются до сложения и вычитания. Скобки гарантируют, что целочисленное деление x / y выполняется сначала.
• Всегда используйте скобки, чтобы сделать свою задумку ясной, особенно когда у вас есть сложные выражения. Это не только делает код легче для чтения, но и гарантирует, что выражение будет вычислено именно так, как вы задумали.

Важные замечания:

• PEMDAS/BODMAS помогает предсказать, как будут вычисляться выражения, но помните, что в C++ нет встроенного оператора для возведения в степень.
• Если у вас есть сомнения, используйте скобки, чтобы явно определить порядок. Это может сделать ваш код более понятным и предотвратить ошибки, которые могут возникнуть из - за неправильного понимания приоритета операторов.
• Некоторые операторы имеют одинаковый приоритет и вычисляются слева направо. Например, если у вас есть a - b + c, то вычитание будет выполнено до сложения.
• Будьте особенно осторожны, когда комбинируете несколько операторов в одном выражении без использования скобок. Это может привести к неочевидным ошибкам, если вы неправильно понимаете приоритет операторов.

Практика с тернарным условным оператором

В этом шаге вы узнаете о тернарном условном операторе, компактном способе записи простых инструкций if-else в одну строку. Этот оператор предоставляет краткий метод принятия решений в вашем коде.

Откройте WebIDE и создайте новый файл с именем ternary_operator.cpp в директории ~/project:

touch ~/project/ternary_operator.cpp

Добавьте следующий код в файл ternary_operator.cpp:

#include <iostream>

int main() {
    // Basic ternary operator syntax
    // condition? value_if_true : value_if_false

    // Simple comparison
    int x = 10;
    int y = 5;

    // Determine the larger number
    int max_value = (x > y)? x : y;
    std::cout << "Larger value: " << max_value << std::endl;

    // Check if a number is even or odd
    int number = 7;
    std::string result = (number % 2 == 0)? "Even" : "Odd";
    std::cout << number << " is " << result << std::endl;

    // Nested ternary operator
    int a = 15;
    std::string category = (a < 10)? "Small"
                         : (a < 20)? "Medium"
                         : "Large";
    std::cout << "Category: " << category << std::endl;

    // Ternary operator with function calls
    int abs_value = (x < 0)? -x : x;
    std::cout << "Absolute value of x: " << abs_value << std::endl;

    // Ternary operator in output
    std::cout << "Is x greater than y? "
              << ((x > y)? "Yes" : "No") << std::endl;

    return 0;
}

Скомпилируйте и запустите программу:

g++ ternary_operator.cpp -o ternary_operator
./ternary_operator

Пример вывода:

Larger value: 10
7 is Odd
Category: Medium
Absolute value of x: 10
Is x greater than y? Yes

Основные моменты о тернарном операторе:

• Синтаксис: condition? value_if_true : value_if_false. Это сокращенный способ записи инструкции if-else в одну строку.
• Вычисляется condition. Если она истинна, выражение возвращает value_if_true; в противном случае возвращает value_if_false.
• В коде int max_value = (x > y)? x : y; определяет большее число между x и y. Если x больше y, то max_value будет присвоено значение x, в противном случае - значение y. Поскольку x равно 10, а y равно 5, max_value становится равным 10.
• Выражение std::string result = (number % 2 == 0)? "Even" : "Odd"; использует оператор остатка от деления % для проверки, является ли число четным или нечетным. Результатом будет либо "Even", либо "Odd", в зависимости от результата проверки, и он присваивается строковой переменной result.
• Тернарные операторы могут быть вложенными, но это быстро может сделать код трудно читаемым. В примере вложенный тернарный оператор присваивает строку "Small", "Medium" или "Large" переменной category в зависимости от значения целого числа a.
• Пример с int abs_value = (x < 0)? -x : x; демонстрирует, как тернарный оператор можно использовать для получения абсолютного значения x. Если x отрицательное, то оно будет изменено на противоположное, что эквивалентно преобразованию в абсолютное значение. В противном случае будет возвращено x без изменений.
• Последний пример показывает, как результат тернарного оператора можно вывести напрямую: std::cout << "Is x greater than y? " << ((x > y)? "Yes" : "No") << std::endl;

Важные замечания:

• Используйте тернарный оператор с осторожностью, чтобы сохранить читаемость кода. Переизбыток тернарных операторов, особенно вложенных, может сделать код трудно разбираемым.
• Тернарный оператор может стать трудно читаемым, если он слишком сложен. Сложные решения лучше выражать с помощью полных блоков if-else.
• Тернарный оператор в основном используется для простых, прямых условий, когда нужно вернуть или присвоить одно из двух значений.

Резюме

В этом практическом занятии вы научились выполнять основные математические операции в языке C++, включая сложение, вычитание, умножение, деление и взятие остатка от деления. Вы также изучили использование префиксных и постфиксных операторов инкремента и декремента, поняв тонкие различия между ними. Кроме того, вы узнали о реляционных и логических операторах для эффективного сравнения и объединения значений. Более того, вы практиковались в применении побитовых операций для манипуляции двоичными данными и составных операторов присваивания, чтобы упростить и сократить арифметические операции с присваиванием. Наконец, вы поняли порядок выполнения операций при использовании нескольких операторов и использовали тернарный условный оператор для записи кратких условных инструкций. Эти фундаментальные концепции являются важными для создания надежных и эффективных программ на C++. Освоив эти основные операторы, вы будете хорошо подготовлены к решению более сложных задач программирования.