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

Логические выражения и операторы. Урок 6 курса «Python. Введение в программирование»

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

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

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

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

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

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

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

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

Чтобы получить True при использовании оператора 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.

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

>>> y < 15 or x > 8
True

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

>>> 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 в зависимости от того, больше первое число второго или нет.

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

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

← предыдущая следующая →

В этом уроке описаны логические операторы. JavaScript поддерживает три логических оператора: || (ИЛИ), && (И) и ! (НЕ), которые очень часто используются в условных конструкциях, например if, while или for. Благодаря логическим операторам можно объединять два выражения в одно более сложное.

JavaScript: Табnица истинности

Основными логическими или булевыми операциями, названными в честь одного из математиков — Джорджа Буля (1815-1864), являются:

• ИЛИ || – логическое сложение (дизъюнкция) – OR;
• И && – логическое умножение (конъюнкция) – AND;
• НЕ ! – логическое отрицание (инверсия) – NOT.

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

Из этой таблицы видно, что результатом работы оператора ИЛИ || будет false, только если оба его операнда – false; результатом оператора И && будет true, только если оба из его операндов – true. Оператор НЕ ! прост – он получает один операнд и возвращает обратное значение.

Логические операторы не требуют, что бы их операнды были логическими значениями. Стоит отметить, что все значения в языке JavaScript являются либо истинными true, либо ложными false.

На заметку: Ложными (false) значениями являются false, null, undefined

Логическое И (&&)

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

Примеры:

Выполнить код »

Часто оператор И && используется совместно с двумя выражениями сравнения:

Выполнить код »

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

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

Например, в следующем примере число 1 будет воспринято как true, а 0 – как false:

Выполнить код »

Логическое И && начинает работу с вычисления левого операнда. Если получившееся значение может быть преобразовано в false (например, null, undefined, 0, –0, NaN или ""), значит, результат выражения равен false или непреобразованному значению левого выражения. Поэтому вычисление и преобразование второго операнда не выполняется. В противном случае, если значение слева является истинным, тогда результат всего выражения определяется значением справа. Поэтому, когда значение слева является истинным, оператор && вычисляет и возвращает значение справа:

Выполнить код »

Итак, оператор && вычисляет операнды слева направо до первого ложного false аргумента и возвращает его значение, а если все операнды истинные true – то возвращается значение последнего. Если первый операнд – false, то результат будет false, и остальные значения игнорируются.

Такое поведение оператора &&, позволяющее экономить ресурсы и не вычислять правый аргумент, иногда называют «короткой схемой вычислений».

Это особенно заметно, когда выражения, имеющие побочные эффекты (присваивания, инкременты, декременты и вызовы функций), помещаются в правую часть оператора &&:

Выполнить код »

При выполнении логического И && в этом коде возникает ошибка, потому что переменная y не объявлена. Значение левого операнда – true, поэтому интерпретатор переходит к оценке правого операнда. Если изменить значение левого операнда на false, ошибка не возникает:

Выполнить код »

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

Логическое ИЛИ (||)

Оператор логическое ИЛИ || вычисляет дизъюнкцию (логическим сложением) двух операндов. Если хотя бы один или оба операнда преобразуются в true, он возвращает true или непреобразованное значение. Если же оба операнда преобразуются в false, он возвращает false или непреобразованное значение.

Логическое ИЛИ ||, как и логическое И && поддерживает сокращенные вычисления.

В этом прмере правый операнд не оценивается, потому что левый эквивалентен значению true, например:

Выполнить код »

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

Выполнить код »

На заметку: Логическое ИЛИ || вычисляет операнды слева направо до первого истинного значения и возвращает его, а если все значения ложные – то возвращает последнее значение.

Логическое НЕ (!)

Оператор логического НЕ ! является унарным оператором, помещаемым перед одиночным операндом. Он преобразует значение своего операнда в булево значение, затем инвертирует это значение в противоположное и возвращает, полученное в результате инвертирования, булево значение.

Вот некоторые примеры:

Выполнить код »

Таким обазом, оператор ! всегда возвращает true или false, поэтому его можно использовать для преобразования любого значения x в его логический эквивалент, дважды применив этот оператор: !!x.

Выполнить код »

Комбинирование логических операторов

Оператор НЕ !, будучи унарным, имеет высокий приоритет (16) и тесно связан с своим аргументом. Приоритет оператора И && больше, чем приоритет оператора ИЛИ || – соответственно 6 и 5.

Учитывая приоритетность логических операторов, следующие проверки на идентичность дают истинный true результат при любых значениях выражений x и y:

Выполнить код »

В следующем коде сначала будет вычислено правое логическое И &&, а уже потом – &&:

Выполнить код »

Изменить результат сложного выражения можно применив в нужном месте кода скобки ():

Выполнить код »

Итоги

• Логическое И && возвращает true тогда и только тогда, когда оба операнда преобразуются в true.
• Логическое ИЛИ || возвращает true если хотя бы один или оба операнда преобразуются в true.
• Операторы && и || поддерживают сокращенное вычисление: если первого операнда достаточно для определения результата, второй операнд не оценивается. Так, если первый операнд логического И && эквивалентен значению false, то второй операнд не оценивается. В случае с логическим ИЛИ || наоборот, правый операнд не оценивается, если левый эквивалентен значению true.
• Логическое отрицание НЕ ! используется для инверсии (переворачивание смысла) логического значения своего операнда и всегда возвращает true или false.
• С помощью двух логических НЕ !! можно преобразовать значение операнда в его логический эквивалент.
• Логические операторы !, && и || имеют разные приоритеты – соответственно 16, 6 и 5. Поэтому встретившись в одном выражении (без приоритетных скобок) эти операторы выполнятся в указанной последовательности.

Задачи

Общие сведения о логических операторах C++ | Udacity

Простые союзы, такие как «и» и «или», позволяют нам связать наши идеи — даже самые сложные.

Эти два мощных слова могут играть не меньшую роль в языке программирования C++, где они используются в качестве логических операторов.

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

Что такое операторы в C++?

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

C++ использует логические значения для проверки истинности или ложности операторов отношения. Логические значения могут возвращать только 1 (истина) или 0 (ложь) в зависимости от результата сравнения. Как мы увидим ниже, мы можем использовать эти операторы несколькими способами, чтобы привести программу к определенному результату.

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

Реляционные операторы

Реляционные операторы, как кратко упоминалось выше, работают с переменными с определенными значениями и дают логический результат. Они используют такие символы, как ==, !=, <= и >, чтобы проверить, являются ли два операнда одинаковыми, разными, больше или меньше друг друга. Эти операторы выводят 1, если утверждение истинно, и 0, если ложно.

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

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

Использование логических операторов в C++?

Как мы увидим, логические операторы хорошо подходят для проверки правильности двух (или более) сравнительных операций. Затем операторы выводят конкретный ответ, основанный на характере оператора и истинности одного или обоих операндов. В C++ мы часто видим это в форме оператора if/else.

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

Оператор «и» (&&)

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

Ниже приведен практический пример использования оператора && в C++:

  #include  
  с использованием пространства имен    стандартное;
 
  инт   основной  ()
{
cout << "Введите число: ";
 число  {};
цин >> число;
 
, если  (число > 0 && число <= 10)
cout << "Ваше число от 1 до 10";
 еще 
cout << "Ваше число не находится между 1 и 10";
 возврат  0;
} 

Выше мы просим пользователя указать номер. Наш логический оператор «и» проверяет, является ли число больше 0, а также меньше или равно 10. Если оба эти утверждения верны, число должно быть между 1 и 10, и мы можем вывести, что это число кейс.

Если введено число 0 или меньше или число больше 10, программа объявит результат «ложным», отрицая оператор if и вместо этого выводя, что число не находится в диапазоне от 1 до 10.

Оператор «или» (||)

Логический оператор «или» работает аналогично оператору «и» выше. Разница в том, что «или» вернет «истина», если левый или правый операнд истинен. || оператор вернет ложное значение только в том случае, если оба операнда ложны.

Рассмотрим сценарий, в котором выигрыш одного из двух счастливых чисел от 1 до 10 в игре принесет нам приз. В этом примере мы установим счастливые числа на четыре и восемь. Нам нужно написать программу на C++ для проверки победителей:

  #include  
  с использованием пространства имен    стандартное;
  интервал   основной  () {

 cout << "Введите число: ";
 число  {};
цин >> число;
, если  (число == 4 || число == 8)
cout << "Вы выбрали выигрышный номер!";
 еще 
cout << "Извините, в следующий раз повезет. ";
 возврат  0;
} 

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

Оператор «не» (!)

Логический оператор «не» используется для преобразования значения из истинного в ложное или из ложного в истинное. Точно так же, если операнд оценивается как истина, логическое «нет» заставит его оценить как ложь. Если операнд оценивается как ложный, его логический эквивалент «не» будет истинным.

В следующем примере показано одно возможное использование логического оператора «не»:

  #include  
  с использованием пространства имен    стандартное;
 
  инт   основной  ()
{
cout << "Введите число: ";
 интервал  х {};
цин >> х;

, если  (!x == 0)
cout << "Вы ввели число, отличное от 0";
 еще 
cout << "Вы ввели ноль";
 
 возврат  0;
} 

Эта программа настроена на возврат значения true в любое время, когда переменная x не равна нулю. Оператор if проверяет, равен ли x 0, что возвращает false для всех чисел, кроме нуля. ! оператор переворачивает результат с false на true, в результате чего программа выводит истинный результат оператора if:

 Введите число: 786
Вы ввели число, отличное от 0 

При использовании логического оператора «не» важно помнить, что в C++ он имеет очень высокий уровень приоритета. Логическое «не» выполняется перед операторами сравнения, такими как «равно» (==) и «больше чем» ( > ). При кодировании с логическим «не» программист должен убедиться, что программа настроена на выполнение операторов в правильном порядке.

В приведенном ниже примере мы видим, как невыполнение этого требования приводит к проблеме:

  #include  
  с использованием пространства имен    стандартное;
 
  инт   основной  ()
{
 целое число  число1 = 3;
 целое число  число2 = 11;
 
, если  (!число1 > число2)
cout << num1 << " не больше, чем " << num2;
 еще 
cout << num1 << " больше, чем " << num2;
 
 возврат  0;
} 

В этом примере программа сначала выполнит логическое ! перед выполнением сравнения. При этом программа ошибочно возвращает следующее:

 3 больше 11 

Чтобы все исправить, нам нужно изменить наш оператор if следующим образом:

 если (!(число1 > число2)) 

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

Таблица истинности логических операций

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

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

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

Битовые операторы в сравнении с логическими операторами

Битовые операторы выглядят и функционируют аналогично логическим операторам, но работают только со значениями целочисленного типа, а не с логическими значениями. Побитовые операторы сравнивают два целых числа побитно и выводят 1 или 0 в зависимости от результата операции.

Для сравнения, побитовое «и» (&) очень похоже на логическое «и» (&&). Аналогично, побитовое «или» (|) следует тому же соглашению, что и логическое «или» (||). К счастью, побитовое «не» (~) выглядит существенно иначе, чем логическое «не» (!).

Смешение этих операторов приведет к ошибкам компиляции в вашей программе.

Изучайте C++ с помощью Udacity

Теперь, когда вы лучше понимаете логические операторы, вы готовы взяться за новые возможности C++.

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

Зарегистрируйтесь в нашей программе C++ Nanodegree уже сегодня!

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

Первые два логических оператора && и никогда не появляются сами по себе. Они обычно идут между двумя или более реляционными тестами. Таблица 2.9 ниже показывает как работает каждый логический оператор. Их называют таблицами истинности, потому что они показать, как добиться истинного результата от , если оператор , использующий эти операторы.

Истинно и ложно с каждой стороны операторов представляют относительные , если тест. Следующие утверждения являются примерами логических операторов

if((ad)) cout <<"Истинно, когда a< б и в то же время в>г»;

Переменная a должна быть меньше b и в то же время c должна быть больше d для выполнения cout. Здесь показан еще один пример, чтобы продемонстрировать оператор НЕ,

if(!(оценка<70)) cout << "студент прошел курс";

Если оценка больше или равна 70 (эквивалентно не менее 70), cout будет выполняться.

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

Пример
/* Эта программа проверяет, является ли год, введенный пользователем, летним Олимпийский год, год переписи населения США или и то, и другое (олимпийский год проводится каждые 4 года, а перепись каждые 10 лет) */

#include