Унарные операции Унарный минус (-)Операция унарного минуса выполняет арифметическое отрицание своего операнда. Операнд должен быть целым или плавающим значением. Выполняются преобразования операнда по умолчанию. Тип результата совпадает с преобразованным типом

Операции В языке Си предусматриваются поразрядные логические операции и операции сдвига. Далее мы будем записывать значения в двоичном коде, чтобы вы могли видеть, как выполняются операции. В реальных программах используются целые переменные или константы, записанные в

Операции Теперь рассмотрим, что можно и нельзя делать с величинами типа enum. Вы можете присвоить константу типа enum переменной того же типа enum feline pet;pet = tiger;Нельзя использовать другие операции присваивания: pet += cat; /* недопустимо */Можно провести сравнение с целью выявления

4.3. Операции сравнения и логические операции Символ операции Значение Использование! Логическое НЕ!expr меньше exprexpr = Меньше либо равно expr=expr больше exprexpr = больше либо равно expr=expr == равно expr==expr != не равно expr!=expr логическое

Операции is и as Операция is предназначена для проверки того, имеет ли классовая переменная указанный динамический тип. Операция as позволяет безопасно преобразовать переменную одного классового типа к другому классовому типу (в отличие от явного приведения классового

Последнее обновление: 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.

Операция декремента или уменьшения значения на единицу. Также существует префиксная форма декремента (--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.

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

Одними из самых первых операци, с которыми сталкивается изучающий язык программирования 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, могут быть переопределены (перегружены).

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

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

Операции увеличения и уменьшения на 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 ;

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

В Си используются следующие обозначения для логических операций:

|| логическое "или" (логическое сложение)

&& логическое "и" (логическое умножение)

Логическое "не" (логическое отрицание)

Логические константы "истина" и "ложь" обозначаются через true и false (это ключевые слова языка). Примеры логических выражений:

bool a, b, c, d;

a = b || c; // логическое "или"

d = b && c; // логическое "и"

a = !b; // логическое "не"

a = (x == y); // сравнение в правой части

a = false; // ложь

b = true; // истина

c = (x > 0 && y != 1); // c истинно, когда

// оба сравнения истинны

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

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

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

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

Арифметическое отрицание (отрицание и дополнение);

~ побитовое логическое отрицание (дополнение);

Логическое отрицание;

* разадресация (косвенная адресация);

& вычисление адреса;

Унарный плюс;

Увеличение (инкремент);

Уменьшение (декремент);

sizeof размер.

Унарные операции выполняются справа налево.

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

A префиксная форма

A++ постфиксная форма

#include

#include

{//демонстрирует различия в выражениях

printf("a = %d b = %d \n",a,b);

printf("a = %d b = %d \n",a++,++b);

Результат

В отличие от унарных, бинарные операции , список которых приведен в табл., выполняются слева направо.

Таблица

Левый операнд операции присваивания должен быть выражением, ссылающимся на область памяти (но не объектом объявленным с ключевым словом const), такие выражения называются леводопустимыми к ним относятся:

Идентификаторы данных целого и плавающего типов, типов указателя, структуры, объединения;

Индексные выражения, исключая выражения имеющие тип массива или функции;

Выражения выбора элемента (->) и (.), если выбранный элемент является леводопустимым;

Выражения унарной операции разадресации (*), за исключением выражений, ссылающихся на массив или функцию;

Выражение приведения типа если результирующий тип не превышает размера первоначального типа.

При записи выражений следует помнить, что символы (*), (&), (!), (+) могут\ обозначать унарную или бинарную операцию.

Преобразование типов

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

При выполнении операций осуществляются обычные арифметические преобразования (которые были рассмотрены выше);

При выполнении операций присваивания, если значение одного типа присваивается переменной другого типа;

При передаче аргументов функции.

Кроме того, в Си есть возможность явного приведения значения одного типа к другому.

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

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

Преобразование целого со знаком к плавающему типу происходит без потери] информации, за исключением случая преобразования значения типа long int или unsigned long int к типу float, когда точность часто может быть потеряна.

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

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

Целые значения без знака преобразуются к плавающему типу, путем преобразования целого без знака к значению типа signed long, а затем значение signed long преобразуется в плавающий тип. Преобразования из unsigned long к типу float, double или long double производятся с потерей информации, если преобразуемое значение больше, чем максимальное положительное значение, которое может быть представлено для типа long.

Преобразования плавающих типов. Величины типа float преобразуются к типу double без изменения значения. Величины double и long double преобразуются к float c некоторой потерей точности. Если значение слишком велико для float, то происходит потеря значимости, о чем сообщается во время выполнения.

При преобразовании величины с плавающей точкой к целым типам она сначала преобразуется к типу long (дробная часть плавающей величины при этом отбрасывается), а затем величина типа long преобразуется к требуемому целому типу. Если значение слишком велико для long, то результат преобразования не определен.

Преобразования из float, double или long double к типу unsigned long производится с потерей точности, если преобразуемое значение больше, чем максимально возможное положительное значение, представленное типом long.

Преобразование типов указателя. Указатель на величину одного типа может быть преобразован к указателю на величину другого типа. Однако результат может быть не определен из-за отличий в требованиях к выравниванию и размерах для различных типов.

Указатель на тип void может быть преобразован к указателю на любой тип, и указатель на любой тип может быть преобразован к указателю на тип void без ограничений. Значение указателя может быть преобразовано к целой величине. Метод преобразования зависит от размера указателя и размера целого типа следующим образом:

Если размер указателя меньше размера целого типа или равен ему, то указатель преобразуется точно так же, как целое без знака;

Если указатель больше, чем размер целого типа, то указатель сначала преобразуется к указателю с тем же размером, что и целый тип, и затем преобразуется к целому типу.

Целый тип может быть преобразован к адресному типу по следующим правилам:

Если целый тип того же размера, что и указатель, то целая величина просто рассматривается как указатель (целое без знака);

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

Преобразования при вызове функции. Преобразования, выполняемые над аргументами при вызове функции, зависят от того, был ли задан прототип функции (объявление "вперед") со списком объявлений типов аргументов.

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

Эти преобразования выполняются независимо для каждого аргумента. Величины типа float преобразуются к double, величины типа char и short преобразуются к int, величины типов unsigned char и unsigned short преобразуются к unsigned int. Могут быть также выполнены неявные преобразования переменных типа указатель. Задавая прототипы функций, можно переопределить эти неявные преобразования и позволить компилятору выполнить контроль типов.

Преобразования при приведении типов. Явное преобразование типов может быть осуществлено посредством операции приведения типов, которая имеет формат:

(имя-типа) операнд.

В приведенной записи имя-типа задает тип, к которому должен быть преобразован операнд.

int i=2; long l=2; double d; float f; d=(double)i * (double)l; f=(float)d; В данном примере величины i,l,d будут явно преобразовываться к указанным в круглых скобках типам.

Одномерные и многомерные массивы.

В программах очень часто приходится обрабатывать большие объёмы однотипных данных. Применять обычные переменные для этого очень неудобно: представьте себе 1000 переменных с разными именами и одинакового типа, которые нельзя обработать в цикле. Эту проблему позволяет решить использование массивов.

Массив – совокупность переменных (элементов) одинакового типа и собщим названием. Доступ к элементам массива осуществляется простым указанием номера элемента – индекса .

В языке Си нумерация элементов массива начинается с нуля!

Примеры объявления массивов:

int a; // Целочисленный массив a, размер – 10 элементов

double vect; // Массив вещественных чисел vect, в нём 20 элементов

char str; // Символьный массив на 1024 элемента

При объявлении массива его элементам можно сразу присвоить нужные значения (т.е. инициализировать массив):

int x = {10, 20, 30, 40, 50};

char str = “Hello!”; // Автоматическое

int a = {1, 2, 3}; // определение размера

Примеры обращения к элементам массива:

printf(“%d\n”,x);

scanf(“%d”, &x);

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

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

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

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

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

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

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

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

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

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

Из таблицы истинности видно, что результат будет нулевым, если оба бита будут равны 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++