Логические операции в си: Логические операторы в C | Microsoft Docs

Урок #4 — Условия и логические операции

Условие (if else), а также оператор switch case это важные вещи в языке программирования c++. В уроке мы изучим логические операции, а также условные операторы, что применяются в языке программирования C++.

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

Конструкция if — else

За счёт if else можно проверить одно или несколько условий и в случае их успешной проверки будет выполнен один, иначе другой.

Рассмотрим пример:

int a = 2, b = 10;
if (a == b) { // Если a будет равным b, тогда будет выполнен код
	// Здесь код что будет выполнен
	// Если все одна строка кода, то фигурные скобки {}
	// можно не ставить
} else if (a 

Вы можете прописать структуру лишь с одним условием if, а можете дописать в неё сколько-угодно вложенных условий else if.

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

Если необходимо проверить несколько условий в одном операторе, то можно воспользоваться логическим «и» или же логическим «или»:

if (a != b && a > b) {
	// Код будет выполнен, если и первое, и второе условие
	// окажутся верными
}

if (a 

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

Это сокращенная форма if else. Записывается следующим образом:

int x = 90, a = 8;
int res = x 

Проверяем: если “x” будет меньше “а”, то в переменную res устанавливаем их сумму, иначе – их разницу. 

Конструкция switch

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

Пример оператора:

int x = 23;
switch (x) { // Проверяем переменную x
	case 1: // Если переменная будет равна 1, то здесь сработает код
		// Может быть множество строк, а не только одна
		cout 

Операции и выражения

Код программы содержит операции и вызовы функций. Каждая операция включает в себя операнды и операторы, которые определяют требуемые действия. Каждая операция или вызов функции заканчивается символом «;». Если одна строка содержит несколько операторов, то такая строка называется выражением. Выражение может содержать несколько операндов и операторов, и их порядок выполнения внутри выражения задается приоритетом. Если выражение содержит операторы одинакового приоритета, то их выполнение осуществляется слева направо в порядке следования. Результатом вычисления выражения является число, объект, метод или пространство имен.
Выполнение операций и вычисление выражений представляет собой линейный алгоритм, в котором операции выполняются последовательно, в порядке их представления в коде программы.
Ниже перечислены типы операторов в порядке их приоритета

Оператор	Описание
.	Осуществляет доступ к членам класса или структуры.
()	Используется для повышения приоритета других операций. Также используется для вызова метода и делегата.
[]	Индексация, или доступ к элементу массива по его индексу.
++	Постфиксный инкремент (увеличивает на 1 значение после его использования).
—	Постфиксный декремент (уменьшает на 1 значение после его использования).
new	Создание нового объекта или делегата.
typeof()	Получение типа объекта путем вызова стандартного метода GetType() класса Object.
checked(x)	Используется для явного включения проверки переполнения при выполнении арифметических действий и преобразований с данными целого типа.
unchecked(x)	Используется для подавления проверки переполнения при выполнении арифметических действий и преобразований с данными целого типа.
default(x)	Возвращает значение по умолчанию для типа x.
delegate{}	Делегат (анонимная функция).

Унарные операторы

Более низким уровнем приоритета обладают унарные операции. Унарными называются операции, которые производятся над одним операндом.

Бинарные мультипликативные и аддитивные операторы

Далее следуют бинарные мультипликативные и аддитивные операторы. Мультипликативные операторы имеют более высокий уровень приоритета по сравнению с аддитивными. Бинарные операторы выполнятся над двумя операндами, чаще всего одного типа.

Операторы сдвига

Операторы сдвига осуществляют арифметический сдвиг на заданное число разрядов.
Операции сдвига осуществляются только над целочисленными данными.
Арифметический сдвиг предполагает, что при сдвиге числа вправо освобождающиеся разряды заполняются значением знакового разряда если число представлено в знаковой форме, и нулем если число представлено в беззнаковой форме.
Сдвиг числа влево на один разряд соответствует умножению числа на 2. Сдвиг влево на два разряда соответствует умножению на 4, сдвиг на три разряда — умножению на 8 соответственно.
Сдвиг числа вправо на один разряд соответствует его целочисленному делению на 2 (остаток от деления выходит за пределы разрядной сетки).

Операторы сравнения и отношения

Операторы сравнения и отношения возвращают значение True если условие сравнения выполняется и False в противном случае.

Оператор	Описание
x > y	Больше.
x	Меньше.
x >= y	Больше или равно.
x	Меньше или равно.
x == y	Проверка на равенство. y	Логическое исключающее ИЛИ для операндов целого или логического типа (поразрядное).
x && y	Условное И для операндов логического типа.
x || y	Условное ИЛИ для операндов логического типа.
x ?? y	Объединение с NULL: возвращает значение x, но если x=NULL, возвращает значение y.
x ? y : z	Тернарная операция, возвращает y если выполняется выражение x или z в противном случае.

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

Рассмотрим пример

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

Если арифметические или логические операции совмещаются с оператором присваивания, то выполнение производится в следующем порядке:
X +=Y; //аналогично X=X+Y
В качестве знака операции может использоваться один из допустимых символов, представленных в таблице ниже. =

Закрепить тему операторов и выражений Вы можете в разделе Логика
курса Алгоритмика

Автор: Вставская Елена Владимировна

 
Написать комментарий:

Логические выражения и операторы. Python. Урок 5

Логические выражения и логический тип данных

Часто в реальной жизни мы соглашаемся с каким-либо утверждением или отрицаем его. Например, если вам скажут, что сумма чисел 3 и 5 больше 7, вы согласитесь, скажете: «Да, это правда». Если же кто-то будет утверждать, что сумма трех и пяти меньше семи, то вы расцените такое утверждение как ложное.

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

Например, выражение 4 > 5 является логическим, так как его результатом является либо правда, либо ложь. Выражение 4 + 5 не является логическим, так как результатом его выполнения является число.

На позапрошлом уроке мы познакомились с тремя типами данных – целыми и вещественными числами, а также строками. Сегодня введем четвертый – логический тип данных (тип bool). Его также называют булевым. У этого типа всего два возможных значения: True (правда) и False (ложь).

>>> a = True
>>> type(a)
<class 'bool'>
>>> b = False
>>> type(b)
<class 'bool'>

Здесь переменной a было присвоено значение True, после чего с помощью встроенной в Python функции type() проверен ее тип. Интерпретатор сообщил, что это переменная класса bool. Понятия «класс» и «тип данных» в данном случае одно и то же. Переменная b также связана с булевым значением.

В программировании False обычно приравнивают к нулю, а True – к единице. Чтобы в этом убедиться, можно преобразовать булево значение к целочисленному типу:

>>> int(True)
1
>>> int(False)
0

Возможно и обратное. Можно преобразовать какое-либо значение к булевому типу:

>>> bool(3.4)
True
>>> bool(-150)
True
>>> bool(0)
False
>>> bool(' ')
True
>>> bool('')
False

И здесь работает правило: всё, что не 0 и не пустота, является правдой.

Логические операторы

Говоря на естественном языке (например, русском) мы обозначаем сравнения словами «равно», «больше», «меньше». В языках программирования используются специальные знаки, подобные тем, которые используются в математике: > (больше), < (меньше), >= (больше или равно), <= (меньше или равно), == (равно), != (не равно).

Не путайте операцию присваивания значения переменной, обозначаемую в языке Python одиночным знаком «равно», и операцию сравнения (два знака «равно»). Присваивание и сравнение – разные операции.

>>> a = 10
>>> b = 5
>>> a + b > 14
True
>>> a < 14 - b
False
>>> a <= b + 5
True
>>> a != b
True
>>> a == b
False
>>> c = a == b
>>> a, b, c
(10, 5, False)

В данном примере выражение c = a == b состоит из двух подвыражений. Сначала происходит сравнение (==) переменных a и b. После этого результат логической операции присваивается переменной c. Выражение a, b, c просто выводит значения переменных на экран.

Сложные логические выражения

Логические выражения типа kByte >= 1023 являются простыми, так как в них выполняется только одна логическая операция. Однако, на практике нередко возникает необходимость в более сложных выражениях. Может понадобиться получить ответа «Да» или «Нет» в зависимости от результата выполнения двух простых выражений. Например, «на улице идет снег или дождь», «переменная news больше 12 и меньше 20».

В таких случаях используются специальные операторы, объединяющие два и более простых логических выражения. Широко используются два оператора – так называемые логические И (and) и ИЛИ (or).

Чтобы получить True при использовании оператора and, необходимо, чтобы результаты обоих простых выражений, которые связывает данный оператор, были истинными. Если хотя бы в одном случае результатом будет False, то и все сложное выражение будет ложным.

Чтобы получить True при использовании оператора or, необходимо, чтобы результат хотя бы одного простого выражения, входящего в состав сложного, был истинным. В случае оператора or сложное выражение становится ложным лишь тогда, когда ложны оба составляющие его простые выражения.

Допустим, переменной x было присвоено значение 8 (x = 8), переменной y присвоили 13 (y = 13). Логическое выражение y < 15 and x > 8 будет выполняться следующим образом. Сначала выполнится выражение y < 15. Его результатом будет True. Затем выполнится выражение x > 8. Его результатом будет False. Далее выражение сведется к True and False, что вернет False.

>>> x = 8
>>> y = 13
>>> y < 15 and x > 8
False

Если бы мы записали выражение так: x > 8 and y < 15, то оно также вернуло бы False. Однако сравнение y < 15 не выполнялось бы интерпретатором, так как его незачем выполнять. Ведь первое простое логическое выражение (x > 8) уже вернуло ложь, которая, в случае оператора and, превращает все выражение в ложь.

В случае с оператором or второе простое выражение проверяется, если первое вернуло ложь, и не проверяется, если уже первое вернуло истину. Так как для истинности всего выражения достаточно единственного True, неважно по какую сторону от or оно стоит.

>>> y < 15 or x > 8
True

В языке Python есть еще унарный логический оператор not, т. е. отрицание. Он превращает правду в ложь, а ложь в правду. Унарный он потому, что применяется к одному выражению, стоящему после него, а не справа и слева от него как в случае бинарных and и or.

>>> not y < 15
False

Здесь у < 15 возвращает True. Отрицая это, мы получаем False.

>>> a = 5
>>> b = 0
>>> not a
False
>>> not b
True

Число 5 трактуется как истина, отрицание истины дает ложь. Ноль приравнивается к False. Отрицание False дает True.

Практическая работа

1. Присвойте двум переменным любые числовые значения.

2. Используя переменные из п. 1, с помощью оператора and составьте два сложных логических выражения, одно из которых дает истину, другое – ложь.

3. Аналогично выполните п. 2, но уже с оператором or.

4. Попробуйте использовать в логических выражениях переменные строкового типа. Объясните результат.

5. Напишите программу, которая запрашивала бы у пользователя два числа и выводила бы True или False в зависимости от того, больше первое число второго или нет.

Примеры решения и дополнительные уроки в android-приложении и pdf-версии курса

Примеры программирования микроконтроллеров, создание схем на микроконтроллерах, микроконтроллеры для начинающих

Операции языка C++ | ITandLife.

ru

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

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

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

a = 5 b = 5 c = 8

Внимание

При присваивании производится преобразование типа выражения к типу 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 << "\nsizeof x :" << sizeof x;
cout << "\nsizeof (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

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

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

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

Сравнивают первый операнд со вторым. Операнды могут быть арифметического типа или указателями. 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;

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

Логические операторы — cppreference.

com

Возвращает результат логической операции.

[править] Объяснение

Выражения логического оператора имеют вид

1) Логическое НЕ

2) Логическое И

3) Логическое включительно ИЛИ

Если операнд не является bool, он преобразуется в bool с помощью контекстного преобразования в bool: он правильно сформирован, только если объявление bool t (arg) правильно сформировано, для некоторых придуманных временных t .

Результат — логическое значение pr.

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

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

Для встроенного логического оператора ИЛИ результат будет истиной, если либо первый, либо второй операнд (или оба) истинны.Этот оператор является коротким замыканием: если первый операнд истинен, второй операнд не оценивается.

Обратите внимание, что побитовые логические операторы не выполняют короткое замыкание.

[править] Результаты

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

[править] Пример

 #include 
#include <строка>
int main ()
{
    int n = 2;
    int * p = & n;
    // указатели можно преобразовать в bool
    if (p && * p == 2 // "* p" можно использовать после "p &&"
       || ! p && n! = 2) // || имеет более низкий приоритет, чем &&
        std :: cout << "истина \ п";

    // потоки также можно преобразовать в bool
    std :: cout << "Введите 'quit', чтобы выйти. \ п ";
    for (std :: string line; std :: cout << ">"
                          && std :: getline (std :: cin, строка)
                          && line! = "выйти"; )
        ;
} 

Выход:

 правда
Введите "quit", чтобы выйти.
> тест
> выйти из 

[править] Стандартная библиотека

Потому что свойства короткого замыкания оператора && и оператора || не применяются к перегрузкам, и поскольку типы с логической семантикой встречаются редко, только два стандартных библиотечных класса перегружают эти операторы:

[править] См.

б
а << б
а >> б

! A
a && b
a || б

a == b
a! = B
a a> b
a <= b
a> = b
a <=> b

a [b]
* a
и a
a-> b
a.б
а -> * б
а. * б

а (…)
а, б
? :

  0 && 0 / * Возвращает 0. * /
0 && 1 / * Возвращает 0.* /
2 && 0 / * Возвращает 0. * /
2 && 3 / * Возвращает 1. * /
  

  0 || 0 / * Возвращает 0. * /
0 || 1 / * Возвращает 1. * /
2 || 0 / * Возвращает 1. * /
2 || 3 / * Возвращает 1. * /
  

 ! 1 / * Возвращает 0. * /
! 5 / * Возвращает 0. * /
! 0 / * Возвращает 1. * /
  

  const char * name_for_value (целое значение)
{
    static const char * names [] = {"ноль", "один", "два", "три",};
    перечисление {NUM_NAMES = sizeof (имена) / sizeof (имена [0])};
    return (значение> = 0 && значение <ЧИСЛО)? имена [значение]: "бесконечность";
}
  

  if (skill == ‘C’ && experience> = 2)
{
    // Он имеет право на работу
}  

  if (сегодня == суббота || сегодня == воскресенье)
{
    // Выходные
}  

  если (! Зарегистрировано)
{
    // Зарегистрируем человека
}  

    печать (4 и 5) -> 5
    print (nil и 13) -> nil
    печать (ложь и 13) -> ложь
    печать (4 или 5) -> 4
    печать (ложь или 5) -> 5
 

    если не x, то x = v конец
 

    а? до н.э
 

    max = (x> y) и x или y
 

    печать (не ноль) -> истина
    печать (не ложь) -> истина
    печать (не 0) -> ложь
    печать (не ноль) -> ложь