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

Унарные операции:

«-» - «унарный минус» применяется к арифметическим операндам (целым, вещественным переменным или константам), результат операции значение операнда с противоположным знаком;

«+» - «унарный плюс» операция ничего не делает, введена для симметрии с операцией «унарный минус»;

«*» - «обращение по адресу», операция применяется к указателям, результат операции значение объекта (операнда), на который указывает указатель;

«&» - «получение адреса», результат операции – адрес объекта (переменной);

«~» - «поразрядное отрицание» операция применяется только к целым операндам, результат операции целое значение, в котором разряды исходного операнда инвертированы;

«!» - «логическое отрицание» («логическое НЕ»), дает в результате значение 0, если операнд есть истина (не нуль), и значение 1, если операнд равен нулю (в Visual C++ тип результата bool), следует отметить, что в базовом Си стандарта ANSI отсутствовал в явном виде логический тип, который бы принимал 2 значения: «истина» и «ложь», вместо логического типа использовался, как правило, целый тип, значение 0- интерпретировалось, как «ложь», любое значение отличное от 0 являлось «истина»;

(<тип>) – «операция преобразования типа», была рассмотрена ранее;

«sizeof» – операция определения размера предназначена для вычисления размера объекта или типа в байтах, и имеет две формы:

sizeof выражение или sizeof(выражение)

sizeof(тип)

Инкремент (увеличение на 1), -- - декремент (уменьшение на 1), имеют две формы записи - префиксную, когда операция записывается перед операндом, и постфиксную. Если операции используются сами по себе (в операторе только одна операция), то разницы между двумя формами нет. Если операция применяется внутри выражения с другими операциями, то в префиксной форме сначала изменяется операнд, а затем его новое значение подставляется в выражение, а в постфиксной форме в выражение подставляется старое значение, а затем изменяется значение операнда. Например,

int i=10, j;

j=++i; // Префиксная форма операции

В результате выполнения данного фрагмента, i и j будут равны 11 (переменной j присваивается новое значение i, увеличенное на 1), если изменить форму операции ++:

int i=10, j;

j=i++; // Постфиксная форма операции

то, после выполнения i будет равно 11, а j будет равно 10, переменной j присваивается старое значение переменной i , а затем оно увеличивается на 1. Операции чаще применяют к целым операндам, но их можно применять к вещественным операндам и даже к указателям.

Бинарные операции можно разделить на следующие классы:

Арифметические:

«+» - бинарный плюс;

«-» - бинарный минус;

«*» - умножение;

«/» - деление;

% - получение остатка от деления.

Первые четыре операции применяются к арифметическим операндам: целым или вещественным, операции «+» и «-» ограниченным способом могут применяться к указателям. Операция – «%» применяется только к целым операндам.

Логические:

«&&» - логическое И;

«||» - логическое ИЛИ;

«^» - логическое исключающее ИЛИ.

Операнды логических операций могут иметь арифметический тип или быть указателями, при этом операнды в каждой операции могут быть различных типов. Преобразования типов не производятся, каждый операнд оценивается с точки зрения его эквивалентности нулю (операнд, равный нулю, рассматривается как «ложь», не равный нулю - как «истина»). В Visual C++ тип результата int или bool в зависимости от типов операндов.

Поразрядные:

«&» - поразрядное И;

«|» - поразрядное ИЛИ;

«^» - поразрядное исключающее ИЛИ;

«>>» - поразрядный сдвиг вправо;

«<<» - поразрядный сдвиг влево.

Данные операции применяются только к целочисленным операндам и работают с их двоичными представлениями. При выполнении операций «&», «|», «^» операнды сопоставляются побитово (первый бит первого операнда с первым битом второго, второй бит первого операнда со вторым битом второго, и т д.).

Операции сдвига сдвигают двоичное представление первого операнда влево или вправо на количество двоичных разрядов, заданное вторым операндом. При сдвиге влево «<<» освободившиеся разряды обнуляются. При сдвиге вправо «>>» освободившиеся биты заполняются нулями, если первый операнд беззнакового типа, и знаковым разрядом в противном случае.

Отношения (сравнения):

«==» - равно (не путать с операцией присваивания «=»);

«!=» - не равно;

«>» - больше;

«<» - меньше;

«>=» - больше или равно;

«<=» - меньше или равно.

Операции отношения сравнивают первый операнд со вторым. Операнды могут быть арифметического типа или указателями. Результатом операции является значение «истина» (любое значение не равное 0, как правило, 1) или «ложь» (0). В Visual C++ тип результата bool .

Присваивания:

«=» - простое присваивание.

Первый операнд должен быть L-значением область памяти будет занесен результат операции. второй - выражением. Сначала вычисляется выражение, стоящее в правой части операции, а потом его результат записывается в область памяти, указанную в левой части. Так называемое, L-значение (L- value) (леводопустимое значение, может быть использовано слева от операции присваивания), так обозначается любое выражение, адресующее некоторый участок памяти, в который можно занести значение.

op= (где op – символ бинарной операции) – комбинированное присваивание, комбинация бинарное операции с операцией присваивания, например, «+=» - присваивание со сложением, по аналогии существуют операции: «*=», «/=», «-=», «%=», «&=», «|=», «^=» и др. Комбинированные операции работают по следующему правилу:

i+=10; аналогично i=i+10;

Другие бинарные операции , просто их перечислим:

() – вызов функции;

– обращение к элементу массива;

«.» («точка») – обращение к полю переменной структурного типа;

«->» - обращение к полю переменной структурного типа через указатель;

«,» («запятая») – последовательное вычисление, может ставится между выражениями, выражения вычисляются последовательно, результат операции результат второго операнда (выражения).

Тернарная операция:

«?:» - условная операция.

Формат: <операнд1> ? <операнд2> : <операнд3>

Первый операнд имеет тип, заменяющий логический – арифметический или указатель, если первый операнд имеет значение «истинно», то результат операции – значение второго операнда, а если «ложь», то результат операции значение третьего операнда. Пример,

y= x>=0 ? x: -x;

переменной y присваивается значения модуля переменной x.

Последнее обновление: 19.06.2017

В C# используется большинство операций, которые применяются и в других языках программирования. Операции представляют определенные действия над операндами - участниками операции. В качестве операнда может выступать переменной или какое-либо значение (например, число). Операции бывают унарными (выполняются над одним операндом), бинарными - над двумя операндами и тернарными - выполняются над тремя операндами. Рассмотрим все виды операций.

Бинарные арифметические операции:

    Операция сложения двух чисел:

    Int x = 10; int z = x + 12; // 22

    Операция вычитания двух чисел:

    Int x = 10; int z = x - 6; // 4

    Операция умножения двух чисел:

    Int x = 10; int z = x * 5; // 50

    операция деления двух чисел:

    Int x = 10; int z = x / 5; // 2 double a = 10; double b = 3; double c = a / b; // 3.33333333

    При делении стоит учитывать, что если оба операнда представляют целые числа, то результат также будет округляться до целого числа:

    Double z = 10 / 4; //результат равен 2

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

    Для выхода из этой ситуации необходимо определять литералы или переменные, участвующие в операции, именно как типы double или float:

    Double z = 10.0 / 4.0; //результат равен 2.5

    Операция получение остатка от целочисленного деления двух чисел:

    Double x = 10.0; double z = x % 4.0; //результат равен 2

Также есть ряд унарных операций, в которых принимает участие один операнд:

    Операция инкремента

    Инкремент бывает префиксным: ++x - сначала значение переменной x увеличивается на 1, а потом ее значение возвращается в качестве результата операции.

    И также существует постфиксный инкремент: x++ - сначала значение переменной x возвращается в качестве результата операции, а затем к нему прибавляется 1.

int x1 = 5; int z1 = ++x1; // z1=6; x1=6 Console.WriteLine($"{x1} - {z1}"); int x2 = 5; int z2 = x2++; // z2=5; x2=6 Console.WriteLine($"{x2} - {z2}");

Операция декремента или уменьшения значения на единицу. Также существует префиксная форма декремента (--x) и постфиксная (x--).

Int x1 = 5; int z1 = --x1; // z1=4; x1=4 Console.WriteLine($"{x1} - {z1}"); int x2 = 5; int z2 = x2--; // z2=5; x2=4 Console.WriteLine($"{x2} - {z2}");

При выполнении сразу нескольких арифметических операций следует учитывать порядок их выполнения. Приоритет операций от наивысшего к низшему:

    Инкремент, декремент

    Умножение, деление, получение остатка

    Сложение, вычитание

Для изменения порядка следования операций применяются скобки.

Рассмотрим набор операций:

Int a = 3; int b = 5; int c = 40; int d = c---b*a; // a=3 b=5 c=39 d=25 Console.WriteLine($"a={a} b={b} c={c} d={d}");

Здесь мы имеем дело с тремя операциями: декремент, вычитание и умножение. Сначала выполняется декремент переменной c, затем умножение b*a, и в конце вычитание. То есть фактически набор операций выглядел так:

Int d = (c--)-(b*a);

Но с помощью скобок мы могли бы изменить порядок операций, например, следующим образом:

Int a = 3; int b = 5; int c = 40; int d = (c-(--b))*a; // a=3 b=4 c=40 d=108 Console.WriteLine($"a={a} b={b} c={c} d={d}");

Ассоциативность операторов

Как выше было отмечено, операции умножения и деления имеют один и тот же приоритет, но какой тогда результат будет в выражении:

Int x = 10 / 5 * 2;

Стоит нам трактовать это выражение как (10 / 5) * 2 или как 10 / (5 * 2) ? Ведь в зависимости от трактовки мы получим разные результаты.

Когда операции имеют один и тот же приоритет, порядок вычисления определяется ассоциативностью операторов. В зависимости от ассоциативности есть два типа операторов:

    Левоассоциативные операторы, которые выполняются слева направо

    Правоассоциативные операторы, которые выполняются справа налево

Все арифметические операторы (кроме префиксного инкремента и декремента) являются левоассоциативными, то есть выполняются слева направо. Поэтому выражение 10 / 5 * 2 необходимо трактовать как (10 / 5) * 2 , то есть результатом будет 4.

В С++ существуют три поразрядные логические операции:

  1. поразрядное И , обозначение: &
  2. поразрядное исключающее ИЛИ , обозначение: ^
  3. поразрядное включающее ИЛИ , обозначение: |

Так же в С++ существуют : ИЛИ — || ; И — && . У многих возникает вопрос, “Чем отличаются операции: & и && ; | и || ?”. Ответ на этот вопрос можно получить, если понять принцип работы поразрядных логических операций. Сразу могу сказать одно, что логические операции && и || используются только для построения логических условий. Тогда как поразрядные логические операции применяются в бинарной арифметике. Данные операции работают с битами ячеек памяти, причём операнды и результат могут быть заданы в другой форме, например, в десятичной. Дальше рассмотрим каждую из операций подробно.

Поразрядная логическая операция И .
Обозначения: X, Y – операнды; F – результат выполнения логической операции

Таблица 1 — Таблица истинности поразрядного И
X Y F
0 0 0
0 1 0
1 0 0
1 1 1

Из таблицы истинности видно, что результат будет нулевым, если хотя бы один из битов 0. Если оба бита равны 1, то результат равен 1.
Пример с числами:
Для упрощения вычислений возьмем четырёхразрядные(4-х разрядный двоичный код) положительные операнды. Сначала переводим числа в двоичный код, а потом выполняем операцию.

1111 = 15 1000 = 8
& 1001 = 9 & 1010 = 10
1001 = 9 1000 = 8
Результат равен 9. Результат равен 8.

Поразрядное исключающее ИЛИ .

Таблица 2 — Таблица истинности поразрядного исключающего ИЛИ
X Y F
0 0 0
0 1 1
1 0 1
1 1 0

Из таблицы истинности видно, что результат будет нулевым, если оба бита будут равны, во всех остальных случаях результат равен 1.
Пример с числами:

1111 = 15 1000 = 8
^ 1001 = 9 ^ 1010 = 10
0110 = 6 0010 = 2
Результат равен 6. Результат равен 2.

Поразрядное включающее ИЛИ .

Таблица 3 — Таблица истинности поразрядного включающего ИЛИ
X Y F
0 0 0
0 1 1
1 0 1
1 1 1

Из таблицы истинности видно, что результат будет нулевым, если оба бита будут равны 0, во всех остальных случаях результат равен 1.
Пример с числами:

1111 = 15 1000 = 8
| 1001 = 9 | 1010 = 10
1111 = 15 1010 = 10
Результат равен 15. Результат равен 10.

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

// log.cpp: определяет точку входа для консольного приложения. #include "stdafx.h" #include << "\n 15 & 9 = " << (15 & 9) << endl; cout << "\n 15 ^ 9 = " << (15 ^ 9) << endl; cout << "\n 15 | 9 = " << (15 | 9) << endl; system("pause"); return 0; }

// код Code::Blocks

// код Dev-C++

// log.cpp: определяет точку входа для консольного приложения. #include using namespace std; int main(int argc, char* argv) { cout << "\n 15 & 9 = " << (15 & 9) << endl; cout << "\n 15 ^ 9 = " << (15 ^ 9) << endl; cout << "\n 15 | 9 = " << (15 | 9) << endl; return 0; }

При использовании поразрядных логических операций в логических условиях результат получается такой же, как и при использовании логических операций && || . И это понятно, так как логика у них одинакова!!

В С++ ложному условию соответствует нулевое значение, а истинному любое целое значение большее нуля. Так что константы true и false интерпретируются как целые числа, после чего поразрядные логические операции поразрядно формируют результат условия. Но прямое назначение поразрядных логических операций – это бинарная арифметика. Результат работы программы (см. Рисунок 1).

15 & 9 = 9 15 ^ 9 = 6 15 | 9 = 15 Для продолжения нажмите любую клавишу. . .

Рисунок 1 — Поразрядные логические операции C++

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

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

Операции присваивания (=, +=, -=, *= и т. д.)

Операции присваивания могут использоваться в программе как законченные операторы.

Формат операции простого присваивания (=):

операнд_1 = операнд_2

Первый операнд должен быть L-значением, второй - выражением. Сначала вычисляется выражение, стоящее в правой части операции, а потом его результат записывается в область памяти, указанную в левой части (мнемоническое правило: «присваивание - это передача данных «налево»»). То, что ранее хранилось в этой области памяти, естественно, теряется.

#include
int main() {
int a = 3 , b = 5 , с = 7 ;
a = b; b = a; с = с + 1 ;
cout << "a = " << a;
cout << "\t b = " << b;
cout << "\t с = " << c;
return 0 ;
}

Результат работы программы:

Внимание

При присваивании производится преобразование типа выражения к типу L-значения, что может привести к потере информации.

В сложных операциях присваивания (+=, *=, /= и т п.) при вычислении выражения, стоящего в правой части, используется и L-значение из левой части. Например, при сложении с присваиванием ко второму операнду прибавляется первый, и результат записывается в первый операнд, то есть выражение а += b является более компактной записью выражения а = а + b.

Основные операции языка программирования C++

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

Все приведенные в таблице операции, кроме условной и sizeof, могут быть переопределены (перегружены).

Операция Краткое описание
Унарные операции
:: доступ к области видимости
. выбор
-> выбор
индексация
() вызов функции
<тип>() конструирование
++ постфиксный инкремент
— постфиксный декремент
typeid идентификация типа
dynamic_cast преобразование типа с проверкой на этапе выполнения
static_cast преобразование типа с проверкой на этапе компиляции
reinterpret_cast преобразование типа без проверки
const_cast константное преобразование типа
sizeof размер объекта или типа
— префиксный декремент
++ префиксный инкремент
~ поразрядное отрицание
! логическое отрицание
— арифметическое отрицание (унарный минус)
+ унарный плюс
& взятие адреса
* разадресация
new выделение памяти
delete освобождение памяти
(<тип>) преобразование типа
.* выбор
->* выбор
Бинарные и тернарные операции
* умножение
/ деление
% остаток от деления
+ сложение
— вычитание
<< сдвиг влево
>> сдвиг вправо
< меньше
<= меньше или равно
> больше
>= больше или равно
== равно
!= не равно
& поразрядная конъюнкция (И)
^ поразрядное исключающее ИЛИ
| поразрядная дизъюнкция (ИЛИ)
&& логическое И
|| логическое ИЛИ
? : условная операция (тернарная)
= присваивание
*= умножение с присваиванием
/= деление с присваиванием
%= остаток отделения с присваиванием
+= сложение с присваиванием
-= вычитание с присваиванием
<<= сдвиг влево с присваиванием
>>= сдвиг вправо с присваиванием
&= поразрядное И с присваиванием
|= поразрядное ИЛИ с присваиванием
^= поразрядное исключающее ИЛИ с присваиванием
throw исключение
, последовательное вычисление

Один и тот же знак может интерпретироваться по-разному в зависимости от контекста.

Рассмотрим основные операции подробнее.

Операции увеличения и уменьшения на 1 (++ и —)

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

#include
int main() {
int x = 3 . у = 3 :
printf ("Значение префиксного выражения: %d\n " , ++ х) :
printf ("Значение постфиксного выражения: %d\n " , у++ ) ;
printf ("Значение х после приращения: %d\n " , х) ;
printf ("Значение у после приращения: %d\n " , у) ;
return 0 ;
}

Результат работы программы:

Значение префиксного выражения: 4
Значение постфиксного выражения: 3
Значение х после приращения: 4
Значение у после приращения: 4

Операндом операции инкремента в общем случае является так называемое L-значение (L-value). Так обозначается любое выражение, адресующее некоторый участок памяти, в который можно занести значение. Название произошло от операции присваивания, поскольку именно ее левая (Left) часть определяет, в какую область памяти будет занесен результат операции. Переменная является частным случаем L-значения.

Операция определения размера sizeof

Она предназначена для вычисления размера объекта или типа в байтах, и имеет две формы:

sizeof выражение
sizeof (тип)

#1nclude
int ma1n() {
float x = 1 ;
cout << "sizeof (float) :" << sizeof (float ) ;
cout << "\n sizeof x:" << sizeof x;
cout << "\n sizeof (x + 1.0) :" << sizeof (x + 1.0 ) :
return 0 :
}

Результат работы профаммы:

sizeof (float): 4
sizeof x: 4
sizeof (x + 1.0): 8

Последний результат связан с тем, что вещественные константы по умолчанию имеют тип doublе, к которому, как к более длинному, приводится тип переменной x и всего выражения. Скобки необходимы для того чтобы выражение, стоящее в них, вычислялось раньше операции приведения типа, имеющей больший приоритет, чем сложение.

Операции отрицания (-, ! и ~)

Арифметическое отрицание (унарный минус -) изменяет знак операнда целого или вещественного типа на противоположный. Логическое отрицание (!) дает в результате значение 0, если операнд есть истина (не нуль), и значение 1, если операнд равен нулю. Операнд должен быть целого или вещественного типа, а может иметь также тип указатель. Поразрядное отрицание (~) , часто называемое побитовым, инвертирует каждый разряд в двоичном представлении целочисленного операнда.

Деление (/) и остаток от деления (%)

Операция деления применима к операндам арифметического типа. Если оба операнда целочисленные, результат операции округляется до целого числа, в противном случае тип результата определяется правилами преобразования. Операция остатка от деления применяется только к целочисленным операндам. Знак результата зависит от реализации.

#include
int main() {
int x = 11 , у = 4 ;
float z = 4 ;
printf ("Результаты деления: %d %f\n " , x/ y, x/ z) ;
printf ("Остаток: %d\n " , x% y) ;
return 0 ;
}

Результат работы программы:

Результаты деления: 2 2.750000
Остаток: 3

Операции сдвига (<< и >>)

Применяются к целочисленным операндам. Они сдвигают двоичное представление первого операнда влево или вправо на количество двоичных разрядов, заданное вторым операндом. При сдвиге влево (<<) освободившиеся разряды обнуляются. При сдвиге вправо (>>) освободившиеся биты заполняются нулями, если первый операнд беззнакового типа, и знаковым разрядом в противном случае. Операции сдвига не учитывают переполнение и потерю значимости.

Операции отношения (<. <=, >, >=, ==, !=)

Сравнивают первый операнд со вторым. Операнды могут быть арифметического типа или указателями. Результатом операции является значение true или false (любое значение, не равное нулю, интерпретируется как true). Операции сравнения на равенство и неравенство имеют меньший приоритет, чем остальные операции сравнения.

Внимание

Обратите внимание па разницу между операцией проверки на равенство (==) и операцией присваивания (=), результатом которой является значение, присвоенное левому операнду.

Поразрядные операции (&, |, ^)

Применяются только к целочисленным операндам и работают с их двоичными представлениями. При выполнении операций операнды сопоставляются побитово (первый бит первого операнда с первым битом второго, второй бит первого операнда со вторым битом второго, и т д.).

При поразрядной конъюнкции , или поразрядном И (операция обозначается &) бит результата равен 1 только тогда, когда соответствующие биты обоих операндов равны 1.

При поразрядной дизъюнкции , или поразрядном ИЛИ (операция обозначается |) бит результата равен 1 тогда, когда соответствующий бит хотя бы одного из операндов равен 1.

При поразрядном исключающем ИЛИ (операция обозначается ^) бит результата равен 1 только тогда, когда соответствующий бит только одного из операндов равен 1.

#include
int main() {
cout << "\n 6 & 5 = " << (6 & 5 ) ;
cout << "\n 6 | 5 = " << (6 | 5 ) ;
cout << "\n 6 ^ 5 = " << (6 ^ 5 ) ;
return 0 ;
}

Результат работы программы:

6 & 5 = 4
6 | 5 = 7
6 ^ 5 = 3

Логические операции (&& и ||)

Операнды логических операций И (&&) и ИЛИ (||) могут иметь арифметический тип или быть указателями, при этом операнды в каждой операции могут быть различных типов. Преобразования типов не производятся, каждый операнд оценивается с точки зрения его эквивалентности нулю (операнд, равный нулю, рассматривается как false, не равный нулю - как true).

Результатом логической операции является true или false. Результат операции логическое И имеет значение true только если оба операнда имеют значение true. Результат операции логическое ИЛИ имеет значение true, если хотя бы один из операндов имеет значение true. Логические операции выполняются слева направо. Если значения первого операнда достаточно, чтобы определить результат операции, второй операнд не вычисляется.

Условная операция (?:)

Эта операция тернарная, то есть имеет три операнда.

Ее формат:

операнд_1 ? операнд_2: операнд_3

Первый операнд может иметь арифметический тип или быть указателем. Он оценивается с точки зрения его эквивалентности нулю (операнд, равный нулю, рассматривается как false, не равный пулю - как true). Если результат вычисления операнда 1 равен true, то результатом условной операции будет значение второго операнда, иначе - третьего операнда. Вычисляется всегда либо второй операнд, либо третий. Их тип может различаться. Условная операция является сокращенной формой условного оператора if.

#include
int main() {
int a = 11 , b = 4 , max;
max = (b > a) ? b : a;
printf ("Наибольшее число: %d" , max) ;
return 0 ;
}

Результат работы программы:

Наибольшее число: 11

Другой пример применения условной операции. Требуется, чтобы некоторая целая величина увеличивалась на 1, если ее значение не превышает п, а иначе принимала значение 1:

i = (1 < n) ? i + 1 : 1 ;

По материалам книги Т.А. Павловской «С++. Программирование на языке высокого уровня»