C++ | Операторы
Операторы позволяют выполнить определенные действия с данными. Например, операторы присваивания служат для сохранения данных в переменной, математические операторы предназначены для арифметических вычислений, а условные операторы позволяют в зависимости от значения логического выражения выполнить отдельный участок программы или наоборот не выполнять его.
Математические операторы
Производить арифметические вычисления позволяют следующие операторы:
std::cout << 10 + 15 << std::endl; // 25
std::cout << 35 - 15 << std::endl; // 20
int x = 10;
std::cout << -x << std::endl; // -10
std::cout << 25 * 2 << std::endl; // 50
/ — деление. Если производится деление целых чисел, то остаток отбрасывается и возвращается целое число. Деление вещественных чисел производится классическим способом. Если в выражении участвуют вещественное и целое числа, то целое число автоматически преобразуется в вещественное. Пример:
std::cout << 10 / 3 << std::endl; // 3
std::cout << 10.0 / 3.0 << std::endl; // 3.33333
std::cout << 10.0 / 3 << std::endl; // 3.33333
std::cout << static_cast<double>(10) / 3
<< std::endl; // 3.33333
Целочисленное деление на 0 приведет к неопределенности. Деление вещественного числа на 0 приведет к значению плюс или минус INFINITY (бесконечность), а деление вещественного числа 0.0 на 0.0 — к значению NAN (нет числа):
std::cout << 10.0 / 0.0 << std::endl; // inf
std::cout << -10.0 / 0.0 << std::endl; // -inf
std::cout << 0.0 / 0.0 << std::endl; // nan
// #include <cmath> или #include <math.h>
std::cout << INFINITY << std::endl; // inf
std::cout << -INFINITY << std::endl; // -inf
std::cout << NAN << std::endl; // nan
std::cout << NAN + 1 << std::endl; // nan
std::cout << 0 * INFINITY << std::endl; // nan
std::cout << INFINITY / INFINITY << std::endl; // nan
std::cout << -INFINITY + INFINITY << std::endl; // nan
% — остаток от деления. Обратите внимание на то, что этот оператор нельзя применять к вещественным числам. Пример:
std::cout << 10 % 2 << std::endl; // 0 (10 - 10 / 2 * 2)
std::cout << 10 % 3 << std::endl; // 1 (10 - 10 / 3 * 3)
std::cout << 10 % 4 << std::endl; // 2 (10 - 10 / 4 * 4)
std::cout << 10 % 6 << std::endl; // 4 (10 - 10 / 6 * 6)
++ — оператор инкремента. Увеличивает значение переменной на 1:
int x = 10;
++x; // Эквивалентно x = x + 1;
std::cout << x << std::endl; // 11
-- — оператор декремента. Уменьшает значение переменной на 1:
int x = 10;
--x; // Эквивалентно x = x - 1;
std::cout << x << std::endl; // 9
Операторы инкремента и декремента могут использоваться в постфиксной или префиксной формах:
x++; x--; // Постфиксная форма
++x; --x; // Префиксная форма
При постфиксной форме (x++) возвращается значение переменной перед операцией, а при префиксной форме (++x) — вначале производится операция и только потом возвращается значение. Продемонстрируем это на примере (листинг 4.1).
#include <iostream>
#include <clocale>
int main() {
std::setlocale(LC_ALL, "Russian_Russia.1251");
int x = 0, y = 0;
x = 5;
y = x++; // y = 5, x = 6
std::cout << "Постфиксная форма (y = x++;):" << std::endl
<< "y = " << y << std::endl
<< "x = " << x << std::endl;
x = 5;
y = ++x; // y = 6, x = 6
std::cout << "Префиксная форма (y = ++x;):" << std::endl
<< "y = " << y << std::endl
<< "x = " << x << std::endl;
return 0;
}
В итоге получим следующий результат:
Постфиксная форма (y = x++;):
y = 5
x = 6
Префиксная форма (y = ++x;):
y = 6
x = 6
Если операторы инкремента и декремента используются в сложных выражениях, то понять, каким будет результат выполнения выражения становится сложно. Например, каким будет значение переменной y после выполнения этих инструкций?
int x = 5, y = 0;
y = ++x + ++x;
Чтобы облегчить жизнь себе и всем другим программистам, которые будут разбираться в программе, операторы инкремента и декремента лучше использовать отдельно от других операторов.
Побитовые операторы
Побитовые операторы предназначены для манипуляции отдельными битами. Эти операторы нельзя применять к вещественным числам, логическим значениям и другим более сложным типам. Язык C++ поддерживает следующие побитовые операторы:
~ — двоичная инверсия. Значение каждого бита заменяется на противоположное:
unsigned char x = 100; // 01100100
x = (unsigned char) ~x; // 10011011
// #include <cstdlib>
char str[100] = {0};
_itoa_s(x, str, 100, 2);
std::cout << str << std::endl; // 10011011
unsigned char x = 100; // 01100100
unsigned char y = 75; // 01001011
unsigned char z = x & y; // 01000000
unsigned char x = 100; // 01100100
unsigned char y = 75; // 01001011
unsigned char z = x | y; // 01101111
^ — двоичное исключающее ИЛИ:
unsigned char x = 100; // 01100100
unsigned char y = 250; // 11111010
unsigned char z = x ^ y; // 10011110
<< — сдвиг влево — сдвигает двоичное представление числа влево на один или более разрядов и заполняет разряды справа нулями:
unsigned char x = 100; // 01100100
x = (unsigned char)(x << 1); // 11001000
x = (unsigned char)(x << 1); // 10010000
x = (unsigned char)(x << 2); // 01000000
Оператор <<, используемый для вывода данных в окно консоли, не имеет никакого отношения к побитовому оператору <<.
>> — сдвиг вправо — сдвигает двоичное представление числа вправо на один или более разрядов и заполняет разряды слева нулями, если число положительное:
unsigned char x = 100; // 01100100
x = (unsigned char)(x >> 1); // 00110010
x = (unsigned char)(x >> 1); // 00011001
x = (unsigned char)(x >> 2); // 00000110
Если число отрицательное, то разряды слева заполняются единицами:
char x = -127; // 10000001
x = (char)(x >> 1); // 11000000
x = (char)(x >> 2); // 11110000
x = (char)(x << 1); // 11100000
x = (char)(x >> 1); // 11110000
Оператор >>, используемый для ввода данных, не имеет никакого отношения к побитовому оператору >>.
Наиболее часто двоичное представление числа используется для хранения различных флагов (0 — флаг сброшен, 1 — флаг установлен). Примеры установки, снятия и проверки установки флага приведены в листинге 4.2. Чтобы иметь возможность видеть результат в окне консоли, дополнительно напишем функцию, позволяющую преобразовать число типа unsigned char в строку в двоичном формате.
#include <iostream>
#include <clocale>
char *ucharToBinaryString(unsigned char x, char *str);
int main() {
std::setlocale(LC_ALL, "Russian_Russia.1251");
char str[9] = "";
const unsigned char FLAG1 = 1, FLAG2 = 2, FLAG3 = 4, FLAG4 = 8,
FLAG5 = 16, FLAG6 = 32, FLAG7 = 64, FLAG8 = 128;
unsigned char x = 0; // Все флаги сброшены
std::cout << ucharToBinaryString(x, str) << std::endl; // 00000000
unsigned char y = 0xFF; // Все флаги установлены
std::cout << ucharToBinaryString(y, str) << std::endl; // 11111111
// Устанавливаем флаги FLAG1 и FLAG7
x = x | FLAG1 | FLAG7;
std::cout << ucharToBinaryString(x, str) << std::endl; // 01000001
// Устанавливаем флаги FLAG4 и FLAG5
x = x | FLAG4 | FLAG5;
std::cout << ucharToBinaryString(x, str) << std::endl; // 01011001
// Снимаем флаги FLAG4 и FLAG5
x = x ^ FLAG4 ^ FLAG5;
std::cout << ucharToBinaryString(x, str) << std::endl; // 01000001
// Проверка установки флага FLAG1
if ((x & FLAG1) != 0) {
std::cout << "FLAG1 установлен" << std::endl;
}
std::cout << ucharToBinaryString(FLAG1, str) << '\n'; // 00000001
std::cout << ucharToBinaryString(FLAG2, str) << '\n'; // 00000010
std::cout << ucharToBinaryString(FLAG3, str) << '\n'; // 00000100
std::cout << ucharToBinaryString(FLAG4, str) << '\n'; // 00001000
std::cout << ucharToBinaryString(FLAG5, str) << '\n'; // 00010000
std::cout << ucharToBinaryString(FLAG6, str) << '\n'; // 00100000
std::cout << ucharToBinaryString(FLAG7, str) << '\n'; // 01000000
std::cout << ucharToBinaryString(FLAG8, str) << '\n'; // 10000000
return 0;
}
char *ucharToBinaryString(unsigned char x, char *str) {
int k = 7;
while (k >= 0) {
if ((x & 1) != 0) { // Проверка статуса последнего бита
str[k] = '1';
}
else {
str[k] = '0';
}
x = (unsigned char)(x >> 1); // Сдвиг на один разряд вправо
--k;
}
str[8] = '\0';
return str;
}
Операторы присваивания
Операторы присваивания предназначены для сохранения значения в переменной. Перечислим операторы присваивания доступные в языке C++:
= — присваивает переменной значение. Обратите внимание на то, что хотя оператор похож на математический знак равенства, смысл у него в языке C++ совершенно другой. Справа от оператора присваивания может располагаться переменная, литерал или сложное выражение. Слева от оператора присваивания может располагаться переменная, указатель или объект (у которого перегружен оператор =), но не литерал или выражение. Пример присваивания значения:
int x;
x = 10;
x = 12 * 10 + 45 / 5;
12 + 45 = 45 + 5; // Так нельзя!!!
В одной инструкции можно присвоить значение сразу нескольким переменным:
int x, y, z;
x = y = z = 2;
+= — увеличивает значение переменной на указанную величину:
x += 10; // Эквивалентно x = x + 10;
-= — уменьшает значение переменной на указанную величину:
x -= 10; // Эквивалентно x = x - 10;
*= — умножает значение переменной на указанную величину:
x *= 10 + 5; // Эквивалентно x = x * (10 + 5);
/= — делит значение переменной на указанную величину:
x /= 2; // Эквивалентно x = x / 2;
%= — делит значение переменной на указанную величину и возвращает остаток:
x %= 2; // Эквивалентно x = x % 2;
&=, |=, ^=, <<= и >>= — побитовые операторы с присваиванием.
Оператор запятая
Оператор запятая позволяет разместить сразу несколько выражений внутри одной инструкции. Например, в предыдущих примерах мы использовали этот оператор для объявления нескольких переменных в одной инструкции:
Результат вычисления последнего выражения можно присвоить какой-либо переменной. При этом выражения должны быть расположены внутри круглых скобок, так как приоритет оператора запятая меньше приоритета оператора присваивания. Пример:
int x = 0, y = 0, z = 0;
x = (y = 10, z = 20, y + z);
std::cout << x << std::endl; // 30
std::cout << y << std::endl; // 10
std::cout << z << std::endl; // 20
В этом примере после объявления и инициализации переменных переменной y присваивается значение 10, затем переменной z присваивается значение 20, далее вычисляется выражение y + z и его результат присваивается переменной x.
Операторы сравнения
Операторы сравнения используются в логических выражениях. Перечислим операторы сравнения, доступные в языке C++:
== — равно;
!= — не равно;
< — меньше;
> — больше;
<= — меньше или равно;
>= — больше или равно.
Логические выражения возвращают только два значения true (Истина, соответствует числу 1) или false (Ложь, соответствует числу 0). Пример вывода значения логического выражения:
std::cout << (10 == 10) << std::endl; // 1 (true)
std::cout << (10 == 5) << std::endl; // 0 (false)
std::cout << (10 != 5) << std::endl; // 1 (true)
std::cout << (10 < 5) << std::endl; // 0 (false)
std::cout << (10 > 5) << std::endl; // 1 (true)
std::cout << (10 <= 5) << std::endl; // 0 (false)
std::cout << (10 >= 5) << std::endl; // 1 (true)
std::cout << std::boolalpha;
std::cout << (10 == 10) << std::endl; // true
std::cout << (10 == 5) << std::endl; // false
Логическое выражение может не содержать операторов сравнения вообще. В этом случае число 0 автоматически преобразуется в ложное значение (false), а любое ненулевое значение (в том числе и отрицательное) — в истинное значение (true):
std::cout << std::boolalpha;
std::cout << (bool)10 << std::endl; // true
std::cout << (bool)-10 << std::endl; // true
std::cout << (bool)12.5 << std::endl; // true
std::cout << (bool)0.1 << std::endl; // true
std::cout << (bool)"str" << std::endl; // true
std::cout << (bool)"" << std::endl; // true
std::cout << (bool)0.0 << std::endl; // false
std::cout << (bool)0 << std::endl; // false
std::cout << (bool)NULL << std::endl; // false
std::cout << (bool)nullptr << std::endl; // false
// #include <cmath> или #include <math.h>
std::cout << (bool)INFINITY << std::endl; // true
std::cout << (bool)NAN << std::endl; // true
В этом примере мы воспользовались приведением к типу bool. Внутри логического выражения приведение типов выполнять не нужно, так как оно производится автоматически.
Следует учитывать, что оператор проверки на равенство содержит два символа =. Указание одного символа = является логической ошибкой, так как этот оператор используется для присваивания значение переменной, а не для проверки условия. Использовать оператор присваивания внутри логического выражения допускается, поэтому компилятор не выведет сообщение об ошибке (возможно отобразит предупреждающее сообщение), однако программа может выполняться некорректно. Подобную ошибку часто допускают начинающие программисты. Например, в следующем примере вместо проверки равенства числу 11, производится операция присваивания:
int x = 10;
if (x = 11) {
std::cout << "x == 11" << std::endl;
}
Выражение внутри круглых скобок присвоит переменной x значение 11, а затем будет произведено сравнение. Любое число не равное 0 трактуется как логическое значение true, поэтому в окне консоли отобразится строка x == 11.
Значение логического выражения можно инвертировать с помощью оператора !. В этом случае если логическое выражение возвращает false, то !false вернет значение true. Пример:
std::cout << (10 == 5) << std::endl; // 0 (false)
std::cout << !(10 == 5) << std::endl; // 1 (true)
Если оператор ! указать дважды, то любое значение преобразуется в логическое:
std::cout << !!10 << std::endl; // 1 (true)
std::cout << !!0 << std::endl; // 0 (false)
std::cout << !!NULL << std::endl; // 0 (false)
Несколько логических выражений можно объединить в одно большое с помощью следующих операторов:
&& — логическое И. Логическое выражение вернет true только в случае, если оба подвыражения вернут true. Пример:
std::cout << ( (10 == 10) && (5 != 3) )
<< std::endl; // 1 (true)
std::cout << ( (10 == 10) && (5 == 3) )
<< std::endl; // 0 (false)
|| — логическое ИЛИ. Логическое выражение вернет true, если хотя бы одно из подвыражений вернет true. Следует учитывать, что если подвыражение вернет значение true, то следующие подвыражения вычисляться не будут. Например, в логическом выражении f1() || f2() || f3() функция f2() будет вызвана только если функция f1() вернет false, а функция f3() будет вызвана, только если функции f1() и f2() вернут false. Пример использования оператора:
std::cout << ( (10 == 10) || (5 != 3) )
<< std::endl; // 1 (true)
std::cout << ( (10 == 10) || (5 == 3) )
<< std::endl; // 1 (true)
Результаты выполнения операторов && и || показаны в табл. 4.1.
Приоритет выполнения операторов
Все операторы выполняются в порядке приоритета (табл. 4.2). Вначале вычисляется выражение, в котором оператор имеет наивысший приоритет, а затем выражение с меньшим приоритетом. Например, выражение с оператором умножения будет выполнено раньше выражения с оператором сложения, так как приоритет оператора умножения выше. Если приоритет операторов одинаковый, то используется порядок вычисления, определенный для конкретного оператора. Операторы присваивания и унарные операторы выполняются справа налево. Математические, побитовые и операторы сравнения, а также оператор запятая выполняются слева направо. Изменить последовательность вычисления выражения можно с помощью круглых скобок. Пример:
int x = 0;
x = 5 + 10 * 3 / 2; // Умножение -> деление -> сложение
std::cout << x << std::endl; // 20
x = (5 + 10) * 3 / 2; // Сложение -> умножение -> деление
std::cout << x << std::endl; // 22
Скачать учебник C++ в формате PDF