Операторы

После введения переменных и констант мы можем начать работать с ними с помощью операторов . Далее следует полный список операторов. На данный момент, вероятно, не обязательно знать все из них, но все они перечислены здесь, чтобы также служить в качестве ссылки.

Оператор присваивания (=)

Оператор присваивания присваивает значение переменной.

x = 5;

Этот оператор присваивает целочисленное значение 5переменной x. Операция присваивания всегда выполняется справа налево и никогда наоборот:

x = y;

Этот оператор присваивает переменной xзначение, содержащееся в переменной y. Значение xна момент выполнения этого оператора теряется и заменяется значением y.

Рассмотрим также , что мы только присваивая значение yдля xв момент операции присваивания. Поэтому, если yизменения в более поздний момент, это не повлияет на новое значение, принятое x.

Например, давайте посмотрим на следующий код: я включил эволюцию содержимого, хранящегося в переменных, в виде комментариев:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// assignment operator
#include <iostream>
using namespace std;

int main ()
{
  int a, b;         // a:?,  b:?
  a = 10;           // a:10, b:?
  b = 4;            // a:10, b:4
  a = b;            // a:4,  b:4
  b = 7;            // a:4,  b:7

  cout << "a:";
  cout << a;
  cout << " b:";
  cout << b;
}
a: 4 b: 7

Эта программа выводит на экран окончательные значения aи b(4 и 7 соответственно). Обратите внимание на то, как aокончательная модификация не повлияла на нее b, хотя мы заявляли a = bранее.

Операции присваивания – это выражения, которые могут быть оценены. Это означает, что само присваивание имеет значение, а для фундаментальных типов – это значение, назначенное в операции. Например:

 
y = 2 + (x = 5);

В этом выражении yприсваивается результат добавления 2 и значения другого выражения присваивания (которое само имеет значение 5). Это примерно эквивалентно:

1
2
x = 5;
y = 2 + x;

С окончательным результатом присвоения 7 к y.

В C ++ также справедливо следующее выражение:

x = y = z = 5;

Он назначает 5 на все три переменные: xyи z; всегда справа налево.

Арифметические операторы (+, -, *, /,%)

Пять арифметических операций, поддерживаемых C ++:

оператор описание
+ прибавление
- вычитание
* умножение
/ деление
% по модулю

Операции сложения, вычитания, умножения и деления буквально соответствуют их соответствующим математическим операторам. Последний, по модулю оператор , представленный знаком процента ( %), дает остаток от деления двух значений. Например:

x = 11 % 3;

приводит к переменной, xсодержащей значение 2, так как разделение 11 на 3 приводит к 3, с остатком от 2.

Соединение (+ =, – =, * =, / =,% =, >> =, << =, & =, ^ =, | =)

Операторы вспомогательного присваивания изменяют текущее значение переменной, выполняя на ней операцию. Они эквивалентны присвоению результата операции первому операнду:

выражение эквивалент …
y += x; y = y + x;
x -= 5; x = x - 5;
x /= y; x = x / y;
price *= units + 1; price = price * (units+1);

и то же самое для всех других составных операторов присваивания. Например:

1
2
3
4
5
6
7
8
9
10
11
// compound assignment operators
#include <iostream>
using namespace std;

int main ()
{
  int a, b=3;
  a = b;
  a+=2;             // equivalent to a=a+2
  cout << a;
}
5

Приращение и декремент (++, -)

Некоторое выражение может быть сокращено еще больше: оператор увеличения ( ++) и оператор уменьшения ( --) увеличивают или уменьшают на единицу значение, хранящееся в переменной. Они эквивалентны +=1и -=1соответственно. Таким образом:

1
2
3
++x;
x+=1;
x=x+1;

все эквивалентны по функциональности; три из них увеличивают на единицу значение x.

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

Особенность этого оператора заключается в том, что он может использоваться как префикс, так и как суффикс. Это означает, что он может быть написан либо перед именем переменной ( ++x), либо после него ( x++). Хотя в простых выражениях x++или++x, оба имеют точно такое же значение; в других выражениях, в которых оценивается результат операции увеличения или уменьшения, они могут иметь важное различие в их значении: в случае, когда оператор увеличения используется в качестве префикса ( ++x) значения, выражение оценивается как окончательное значение x, когда оно уже увеличено. С другой стороны, в случае, если он используется как суффикс ( x++), значение также увеличивается, но выражение оценивается до значения, которое было до того, как оно было увеличено. Обратите внимание на разницу:

Пример 1 Пример 2.
x = 3;
y = ++x;
// x contains 4, y contains 4
x = 3;
y = x++;
// x contains 4, y contains 3

В примере 1 значение, присвоенное значению, yявляется значением xпосле увеличения. Хотя в примере 2 это значение xбыло увеличено.

Операторы отношения и сравнения (==,! =,>, <,> =, <=)

Два выражения можно сравнить с помощью реляционных и равномерных операторов. Например, чтобы знать, являются ли два значения равными или один больше другого.Результатом такой операции является либо истинное, либо ложное (т. Е. Булево значение).Реляционными операторами в C ++ являются:

оператор описание
== Равно
!= Не равен
< Меньше, чем
> Больше чем
<= Меньше или равно
>= Больше или равно

Вот несколько примеров:

1
2
3
4
5
(7 == 5)     // evaluates to false
(5 > 4)      // evaluates to true
(3 != 2)     // evaluates to true
(6 >= 6)     // evaluates to true
(5 < 5)      // evaluates to false 

Конечно, это не просто числовые константы, которые можно сравнить, а просто любое значение, в том числе, конечно, переменные. Предположим , что a=2b=3и c=6, затем:

1
2
3
4
(a == 5)     // evaluates to false, since a is not equal to 5
(a*b >= c)   // evaluates to true, since (2*3 >= 6) is true
(b+4 > a*c)  // evaluates to false, since (3+4 > 2*6) is false
((b=2) == a) // evaluates to true 

Быть осторожен! Оператор присваивания (оператор =с одним знаком равенства) не совпадает с оператором сравнения равенства (оператор ==с двумя равными знаками); первый ( =) присваивает значение правой части переменной слева, а другой ( ==) сравнивает, равны ли значения по обе стороны оператора. Поэтому в последнем выражении ( (b=2) == a), мы сначала присваивается значение 2к , bа затем мы сравнивали его с a(что также сохраняет значение 2), что дает true.

Логические операторы (!, &&, ||)

Оператором !является оператор C ++ для булевой операции NOT. Он имеет только один операнд, справа и инвертирует его, создавая, falseесли его операнд true, и trueесли его операнд false. В принципе, он возвращает противоположное логическое значение для оценки его операнда. Например:

1
2
3
4
!(5 == 5)   // evaluates to false because the expression at its right (5 == 5) is true
!(6 <= 4)   // evaluates to true because (6 <= 4) would be false
!true       // evaluates to false
!false      // evaluates to true 

Логические операторы &&и ||используются при оценке двух выражений для получения единственного реляционного результата. Оператор &&соответствует логической логической операции AND, которая дает, trueесли оба операнда есть true, и в falseпротивном случае. Следующая панель показывает результат оператора, &&вычисляющего выражение a&&b:

&& ОПЕРАТОР (и)
a b a && b
true true true
true false false
false true false
false false false

Оператор ||соответствует логической логической операции OR, которая дает, trueесли любой из ее операндов true, таким образом, является ложным только тогда, когда оба операнда ложны. Вот возможные результаты a||b:

|| ОПЕРАТОР (или)
a b a || b
true true true
true false true
false true true
false false false

Например:

1
2
( (5 == 5) && (3 > 6) )  // evaluates to false ( true && false )
( (5 == 5) || (3 > 6) )  // evaluates to true ( true || false ) 

При использовании логических операторов C ++ оценивает только то, что необходимо слева направо, чтобы придумать комбинированный реляционный результат, игнорируя остальные. Поэтому в последнем примере ( (5==5)||(3>6)) C ++ сначала оценивает, 5==5есть ли true, и если да, то он никогда не проверяет, 3>6есть trueили нет. Это известно как оценка короткого замыкания и работает так для этих операторов:

оператор короткое замыкание
&& если левое выражение стороны false, объединенный результат false(выражение правой стороны никогда не оценивается).
|| если левое выражение стороны true, объединенный результат true(выражение правой стороны никогда не оценивается).

Это в основном важно, когда правое выражение имеет побочные эффекты, такие как изменяющие значения:

 
if ( (i<10) && (++i<n) ) { /*...*/ }   // note that the condition increments i 

Здесь комбинированное условное выражение будет увеличиваться iна единицу, но только если условие слева от &&него true, так как в противном случае условие в правой части ( ++i<n) никогда не оценивается.

Условный тернарный оператор (?)

Условный оператор оценивает выражение, возвращая одно значение, если это выражение оценивается true, и другое, если выражение оценивается как false. Его синтаксис:condition ? result1 : result2If conditionis true, все выражение оценивается result1и в противном случае result2.

1
2
3
4
7==5 ? 4 : 3     // evaluates to 3, since 7 is not equal to 5.
7==5+2 ? 4 : 3   // evaluates to 4, since 7 is equal to 5+2.
5>3 ? a : b      // evaluates to the value of a, since 5 is greater than 3.
a>b ? a : b      // evaluates to whichever is greater, a or b.  

Например:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// conditional operator
#include <iostream>
using namespace std;

int main ()
{
  int a,b,c;

  a=2;
  b=7;
  c = (a>b) ? a : b;

  cout << c << '\n';
}
7

В этом примере aбыло 2 и bбыло 7, поэтому выражение, которое оценивалось ( a>b), не было true, поэтому первое значение, указанное после отметки вопроса, было отброшено в пользу второго значения (после двоеточия), которое было b(с значение 7).

Оператор запятой (,)

Оператор запятой ( ,) используется для разделения двух или более выражений, которые включены, где ожидается только одно выражение. Когда набор выражений должен быть оценен для значения, рассматривается только самое правое выражение.Например, следующий код:

a = (b=3, b+2);

сначала назначит значение 3 b, а затем назначит b+2переменной a. Итак, в конце переменная aбудет содержать значение 5, в то время как переменная bбудет содержать значение 3.

обитовые операторы (&, |, ^, ~, <<, >>)

Побитовые операторы изменяют переменные, учитывая битовые шаблоны, которые представляют значения, которые они хранят.

оператор эквивалент asm описание
& AND Побитовое И
| OR Побитовое включение ИЛИ
^ XOR Побитовое исключение ИЛИ
~ NOT Унарное дополнение (инвертирование бит)
<< SHL Сдвиг бит
>> SHR Сдвинуть биты вправо

Явный оператор преобразования типов

Операторы прещбразования типов позволяют преобразовать значение данного типа в другой тип. В C ++ существует несколько способов сделать это. Самый простой, который был унаследован от языка C, должен предшествовать выражению, которое должно быть преобразовано новым типом, заключенным между круглыми скобками (()):

1
2
3
int i;
float f = 3.14;
i = (int) f;

Предыдущий код преобразует число с плавающей запятой 3.14в целочисленное значение ( 3); остаток теряется. Здесь был приказчик (int). Другой способ сделать то же самое в C ++ – использовать функциональную нотацию, предшествующую выражению, которое должно быть преобразовано типом, и заключить выражение между круглыми скобками:

i = int (f);

В C ++ допустимы оба способа.

 

Оператор sizeof

Этот оператор принимает один параметр, который может быть либо типом, либо переменной, и возвращает размер в байтах этого типа или объекта:

 
x = sizeof (char);

Здесь xприсваивается значение 1, потому что charэто тип с размером одного байта.

Возвращаемое значение sizeofявляется константой времени компиляции, поэтому она всегда определяется перед выполнением программы.

Другие операторы

Позже в этих учебниках мы увидим еще несколько операторов, таких как ссылки на указатели или особенности объектно-ориентированного программирования.

Приоритет операторов

Одно выражение может иметь несколько операторов. Например:

x = 5 + 7 % 2;

В C ++ вышеупомянутое выражение всегда присваивает переменной 6 x, поскольку %оператор имеет более высокий приоритет, чем +оператор, и всегда оценивается ранее. Части выражений могут быть заключены в круглые скобки, чтобы переопределить этот порядок приоритета или явно очистить предполагаемый эффект. Обратите внимание на разницу:

1
2
x = 5 + (7 % 2);    // x = 6 (same as without parenthesis)
x = (5 + 7) % 2;    // x = 0 

От максимального к наименьшему приоритету операторы C ++ оцениваются в следующем порядке:

уровень Группа приоритетов оператор Описание группирование
1 Объем :: спецификатор области Слева направо
2 Постфикс (унарный) ++ -- постфиксный прирост / декремент Слева направо
() функциональные формы
[] индекс
. -> доступ к членству
3 Префикс (унарный) ++ -- приращение префикса / декремент Справа налево
~ ! побитовое NOT / logical NOT
+ - унарный префикс
& * ссылка / разыменование
new delete распределение / освобождение
sizeof пакет параметров
(type) C-образный тип-литье
4 Указатель на член .* ->* указатель доступа Слева направо
5 Арифметика: масштабирование * / % умножать, делить, по модулю Слева направо
6 Арифметика: добавление + - сложение, вычитание Слева направо
7 Побитовый сдвиг << >> сдвиг влево, сдвиг вправо Слева направо
8 реляционный < > <= >= операторы сравнения Слева направо
9 равенство == != равенство / неравенство Слева направо
10 А также & побитовое И Слева направо
11 Эксклюзивный или ^ побитовый XOR Слева направо
12 Включить или | побитовое ИЛИ Слева направо
13 конъюнкция && логическое И Слева направо
14 дизъюнкция || логический ИЛИ Слева направо
15 Выражения на уровне назначений = *= /= %= += -=
>>= <<= &= ^= |=
присвоение / составное назначение Справа налево
?: условный оператор
16 Последовательность действий , разделитель запятой Слева направо

Когда выражение имеет два оператора с одинаковым уровнем приоритета, группировка определяет, какой из них оценивается первым: либо слева направо, либо справа налево.

Включение всех подзапросов в круглых скобках (даже ненужных из-за их приоритета) улучшает читаемость кода.

Залишити відповідь