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

Содержание

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

Добавлено 8 мая 2021 в 18:37

Хотя операторы отношения (сравнения) могут использоваться для проверки того, является ли конкретное условие истинным или ложным, они могут проверять только одно условие за раз. Но часто нам нужно знать, выполняются ли одновременно несколько условий. Например, чтобы проверить, выиграли ли мы в лотерею, мы должны сравнить, все ли выбранные нами числа совпадают с выигрышными числами. В лотерее с 6 числами это будет включать 6 сравнений, и все они должны быть верными. В других случаях нам нужно знать, выполняется ли какое-либо из нескольких условий. Например, мы можем решить пропустить работу сегодня, если мы заболели, или если мы слишком устали, или если мы выиграли в лотерею в нашем предыдущем примере. Это потребует проверки того, верно ли какое-либо из трех сравнений.

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

В C++ есть 3 логических оператора:

Логические операторы
Оператор	Обозначение	Пример использования	Операция
Логическое НЕ (NOT)	`!`	`!x`	`true`, если `x` равен `false`; или `false`, если `x` равен `true`
Логическое И (AND)	`&&`	`x && y`	`true`, если и `x`,и `y` равны `true`; в противном случае – `false`
Логическое ИЛИ (OR)	`\|\|`	`x \|\| y`	`true`, если `x` или `y` равен `true`; в противном случае – `false`

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

Вы уже сталкивались с унарным оператором логического НЕ в уроке «4. 9 – Логические (булевы) значения». Мы можем резюмировать эффекты логического НЕ следующим образом:

Логическое НЕ (оператор `!`)
Операнд	Результат
`true`	`false`
`false`	`true`

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

Логическое НЕ часто используется в условных выражениях:

bool tooLarge { x > 100 }; // tooLarge равно true, если x > 100
if (!tooLarge)
    // делаем что-нибудь с x
else
    // выводим ошибку

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

#include <iostream>
 
int main()
{
    int x{ 5 };
    int y{ 7 };
 
    if (!x > y)
        std::cout << x << " is not greater than " << y << '\n';
    else
        std::cout << x << " is greater than " << y << '\n';
 
    return 0;
}

Эта программа напечатает:

5 is greater than 7

Но x не больше y, так как же это возможно? Ответ заключается в том, что поскольку оператор логического НЕ имеет более высокий приоритет, чем оператор «больше чем», выражение

!x > y фактически вычисляется как (!x) > y. Поскольку x равно 5, !x вычисляется как 0, а 0 > y равно false, поэтому выполняется инструкция else!

Правильный способ написать приведенный выше фрагмент:

#include <iostream>
 
int main()
{
    int x{ 5 };
    int y{ 7 };
 
    if (!(x > y))
        std::cout << x << " is not greater than " << y << '\n';
    else
        std::cout << x << " is greater than " << y << '\n';
 
    return 0;
}

Таким образом, сначала будет вычислено x > y, а затем логическое НЕ инвертирует логический результат.

Лучшая практика

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

Простое использование логического НЕ, например if (!value), не требует скобок, потому что приоритет здесь не играет роли.

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

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

Логическое ИЛИ (оператор `||`)
Левый операнд	Правый операнд	Результат
`false`	`false`	`false`
`false`	`true`	`true`
`true`	`false`	`true`
`true`	`true`	`true`

Например, рассмотрим следующую программу:

#include <iostream>
 
int main()
{
    std::cout << "Enter a number: ";
    int value {};
    std::cin >> value;
 
    if (value == 0 || value == 1)
        std::cout << "You picked 0 or 1\n";
    else
        std::cout << "You did not pick 0 or 1\n";
    return 0;
}

В этом случае мы используем логический оператор ИЛИ, чтобы проверить, истинно ли левое условие (value == 0) или правое условие (value == 1). Если одно из них (или оба) истинны, логический оператор ИЛИ принимает значение true, что означает выполнение инструкции

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

Вы можете связать вместе множество операторов логического ИЛИ:

if (value == 0 || value == 1 || value == 2 || value == 3)
     std::cout << "You picked 0, 1, 2, or 3\n";

Начинающие программисты иногда путают оператор логическое ИЛИ (||) с оператором побитовое ИЛИ (|) (который будет рассмотрен позже). Несмотря на то, что у них обоих в названии есть «ИЛИ», они выполняют разные функции. Их смешивание, вероятно, приведет к неверным результатам.

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

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

В противном случае возвращается false.

Логическое И (оператор `&&`)
Левый операнд	Правый операнд	Результат
`false`	`false`	`false`
`false`	`true`	`false`
`true`	`false`	`false`
`true`	`true`	`true`

Например, нам может потребоваться узнать, находится ли значение переменной x в диапазоне от 10 до 20. На самом деле это два условия: нам нужно знать, больше ли x, чем 10, а также меньше ли x, чем 20.

#include <iostream>
 
int main()
{
    std::cout << "Enter a number: ";
    int value {};
    std::cin >> value;
 
    if (value > 10 && value < 20)
        std::cout << "Your value is between 10 and 20\n";
    else
        std::cout << "Your value is not between 10 and 20\n";
    return 0;
}

В этом случае мы используем оператор логическое И, чтобы проверить, истинны ли левое условие (value > 10) и правое условие (value < 20). Если оба условия истинны, оператор логическое И принимает значение true, и выполняется инструкция if. Если ни одно из условий или хотя бы одно из них не соответствует истине, оператор логическое И принимает значение false, и выполняется инструкция else.

Как и в случае с логическим ИЛИ, вы можете связать вместе множество операторов

логическое И:

if (value > 10 && value < 20 && value != 16)
    // делаем что-то
else
    // делаем что-то другое

Если все эти условия верны, будет выполнена инструкция if. Если какое-либо из этих условий ложно, будет выполняться инструкция else.

Вычисление по короткой схеме

Чтобы логическое И возвращало true, оба операнда должны иметь значение true. Если первый операнд вычисляется как false, логическое И знает, что оно должно возвращать false, независимо от того, вычисляется ли второй операнд как true или false. В этом случае оператор логическое И немедленно вернет false, даже не вычисляя второй операнд! Это известно как вычисление по короткой схеме

и выполняется в основном в целях оптимизации.

Точно так же, если первый операнд для логического ИЛИ равен true, тогда всё условие ИЛИ должно вычисляться как true, и второй операнд не вычисляется.

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

if (x == 1 && ++y == 2)
    // сделать что-то

Если x не равно 1, всё условие должно быть ложным, поэтому ++y никогда не вычисляется! Таким образом, y будет инкрементироваться только в том случае, если x равен 1, что, вероятно, не совсем то, что задумывал программист!

Предупреждение

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

Избегайте использования выражений с побочными эффектами в выражениях с этими операторами.

Как и в случае с логическим и побитовым ИЛИ, начинающие программисты иногда путают оператор логическое И (&&) с оператором побитовое И (&).

Смешивание И и ИЛИ

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

Многие программисты предполагают, что логическое И и логическое ИЛИ имеют одинаковый приоритет (или забывают, что это не так), точно так же, как сложение/вычитание и умножение/деление. Однако логическое И имеет более высокий приоритет, чем логическое ИЛИ, поэтому операторы логическое И будут вычисляться перед операторами логическое ИЛИ (если они не заключены в скобки).

Начинающие программисты часто пишут такие выражения, как value1 || value2 && value3. Поскольку логическое И имеет более высокий приоритет, это выражение вычисляется как value1 || (value2 && value3), а не как (value1 || value2) && value3. Надеюсь, это то, чего хотел программист! Если программист предполагал вычисление слева направо (как это происходит со сложением/вычитанием или умножением/делением), он или она получит не тот результат, который не ожидался!

При смешивании логического И и логического ИЛИ в одном выражении рекомендуется явно заключать в скобки каждый оператор и его операнды. Это помогает предотвратить ошибки приоритета, упрощает чтение кода и четко определяет, как вы рассчитывали вычислять выражение. Например, вместо записи value1 && value2 || value3 && value4, лучше написать (value1 && value2) || (value3 && value4).

Лучшая практика

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

Закон де Моргана

Многие программисты также ошибаются, полагая, что !(x && y) – это то же самое, что !x && !y. К сожалению, так нельзя «распределять» логическое НЕ.

Закон де Моргана говорит нам, как логическое НЕ должно распределяться в этих случаях:

!(x && y) эквивалентно !x || !y
!(x || y) эквивалентно !x && !y

Другими словами, когда вы распределяете логическое НЕ, вам также необходимо преобразовать логическое И в логическое ИЛИ, и наоборот!

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

Где логический оператор исключающее ИЛИ (XOR)?

Логический оператор исключающее ИЛИ (XOR) – это логический оператор, представленный на некоторых языках, который используется для проверки истинности нечетного числа условий.

Логическое исключающее ИЛИ
Левый операнд	Правый операнд	Результат
`false`	`false`	`false`
`false`	`true`	`true`
`true`	`false`	`true`
`true`	`true`	`false`

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

if (a != b) ... // a XOR b, предполагая, что a и b - логические значения

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

if (a != b != c != d) ... // a XOR b XOR c XOR d, предполагая, что a, b, c и d 
                          // являются логическими значениями

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

// a XOR b XOR c XOR d, для любого типа, который можно преобразовать в bool
if (static_cast<bool>(a) != static_cast<bool>(b) != static_cast<bool>(c) != static_cast<bool>(d)) . ..

Небольшой тест

Вопрос 1

Вычислите следующие выражения.

Примечание: в ответах мы «объясняем нашу работу», показывая вам шаги, предпринятые для получения окончательного ответа. Шаги разделены символом →. Выражения, которые были проигнорированы из-за правила вычисления по короткой схеме, помещены в квадратные скобки. Например,

(1 < 2 || 3 != 3) →
(true || [3 != 3]) →
(true) →
true

означает, что мы вычислили (1 <2 || 3 != 3), чтобы прийти к (true || [3 != 3]), и вычислили его, чтобы прийти к true. 3 != 3 никогда не выполнялся из-за вычисления по короткой схеме.

a) (true && true) || false

Ответ

(true && true) || false →
true || [false] →
true

b) (false && true) || true

Ответ

(false && [true]) || true →
false || true →
true

Вычисление по короткой схеме имеет место быть, если первый операнд || равен true.

c) (false && true) || false || true

Ответ

(false && [true]) || false || true →
false || false || true →
false || true →
true

d) (5 > 6 || 4 > 3) && (7 > 8)

Ответ

(5 > 6 || 4 > 3) && (7 > 8) →
(false || true) && false →
true && false →
false

e) !(7 > 6 || 3 > 4)

Ответ

!(7 > 6 || 3 > 4) →
!(true || [3 > 4]) →
!true →
false

Оригинал статьи:

5.7 — Logical operators

C++ / CppLearnCppДля начинающихЛогические операторЛогические типы даныхЛогическое И (AND)Логическое ИЛИ (OR)Логическое исключающее ИЛИ (XOR)Логическое НЕ (NOT)ОбучениеОператор (программирование)Программирование

Оглавление

Вперед

Логические операции and, or и not в Python.

Синтаксис:

x or y
x and y
not x

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

or — оценивает второй аргумент, только если первый равен False. Если какой либо операнд в цепочке or является истиной, немедленно возвращается результат — первое истинное значение.
and — оценивает второй аргумент, только если первый равен True. Если в цепочке and все операнды являются истиной, результатом будет последнее значение. А если какой-либо из операндов является False, результатом будет первое ложное значение.
not имеет более низкий приоритет, чем операторы сравнения, так not a == b интерпретируется как not (a == b), а выражение a == not b вовсе является синтаксической ошибкой. Единственный логический оператор с одним аргументом. Он принимает один аргумент x и возвращает противоположный результат: False для истинного значения и True для ложного значения.

Операторы and и or не приводят свои результаты принудительно к значениям True или False, а возвращают один из своих операндов. Такой подход позволяет использовать эти операторы в более общих, а не только булевых операциях. Если другие операторы, прежде чем выполнить операцию, вычисляют все свои операнды, то в случае операторов and и or с их семантикой закорачивания необходимость вычисления правого операнда определяется результатом вычисления левого.

Из булевых операторов, not имеет самый высокий приоритет, а or самый низкий, так что A and not B or C эквивалентно (A and (not B)) or C. Как всегда, скобки могут быть использованы для выражения желаемого приоритета в операциях.

Логические операции, упорядоченные по приоритету выполнения:

not x — если x ложно, то возвращается True, иначе False.
x and y — если x ложно, то возвращается x, иначе у.
x or y — если x ложно, то возвращается у, иначе x

Также смотрите встроенные функции all() и any()

Пример c and:

a = 'a'
b = 'b'
c = 'c'
>>> a and b
# 'b'
>>> '' and b
# ''
>>> a and b and c
# 'c'

Пояснения к примеру выше с оператором and

Оператор and вычисляет значения в булевом контексте слева направо. Значения 0, '', [], (), {} и None являются ложью, все остальное является истиной. Если у and оба операнда являются истиной, результатом будет последнее значение.
Если какой-либо из операндов является ложью, результатом будет первое такое значение. В данном случает это '' — пустая строка, первое значение которое является ложью.
Все значения являются истиной, так что в результате мы получаем последнее c.

Пример c or:

a = 'a'
b = 'b'
>>> a or b
# 'a'
>>> '' or b
# 'b'
>>> '' or [] or {}
# {}
>>> def func():
...        return 1
>>> a or func()
# 'a'

Пояснения к примеру выше с оператором or

Оператор or вычисляет значения в булевом контексте слева направо. Если операнд является истиной, or немедленно возвращает результат. В данном случае a, первое истинное значение.
or вычисляет выражение '', которое является ложью, затем b, которое является истиной, и возвращает его значение.
Если все значения являются ложью, or возвращает последнее.
Обратите внимание, что or вычисляет операнды до тех пор, пока не найдет истинное значение, остальное игнорируется. Это имеет значение, когда вычисление операнда дает сторонние эффекты. В данном случае функция func() не вызывается, так как для получения результата выражения с оператором or достаточно того, что первый операнд a является истиной.

Другие примеры с and и or:

>>> a = 'one'
>>> b = 'two'
>>> 1 and a or b
# 'one'
>>> 0 and a or b
# 'two'
>>> a = ''
>>> b = 'two'
# 'a' - пустая строка, которую Python считает ложью,
# следовательно 1 and '' дает '', а '' or 'two' дает 'two'.
>>> 1 and a or b
# 'two'

Логические операторы стиля C (короткого замыкания) (Programming Perl)

Глава 3.

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

Подобно C, Perl предоставляет операторы && (логическое И) и || (логический ИЛИ) операторы. Они оценивают слева направо (с && имеет несколько более высокий приоритет, чем ||) проверка истинности утверждение. Эти операторы известны как операторы короткого замыкания, потому что они определяют истинность утверждения, оценивая наименьшее возможное количество операндов. Например, если левый операнд Оператор && является ложным, правильный операнд никогда не оценивается потому что результат оператора ложный независимо от значения правильный операнд.

долларов США

Пример	Имя	Результат
$a && $b	и	$a, если $a ложно, иначе $b
$а \|\|	или	$a, если $a верно, иначе $b

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

 открыть(ФАЙЛ, "какой-то файл") || die "Не удается открыть файл: $!\n";

В этом случае Perl сначала оценивает открытая функция. Если значение истинно (потому что какой-то файл был успешно открыт), выполнение функции штампа не требуется, и поэтому пропущено. Вы можете прочитать это буквально как «Открой какой-нибудь файл или умри!»

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

 $home = $ENV{HOME}
     || $ENV{ЛОГКАТАЛОГ}
     || (получитьpwuid($<))[7]
     || die "Ты бездомный!\n";

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

 @а = @б || @с; # Это не правильно
@a = скаляр(@b) || @с; # потому что это действительно означает это. 
@а = @б ? @до н.э; # Однако это прекрасно работает.

Perl также обеспечивает более низкий приоритет и или операторы, которые некоторые люди находят более читаемыми и не заставляйте вас использовать круглые скобки в операторах списка. Они тоже короткое замыкание. См. Таблицу 3-1 для полный список.


3.13. Побитовые операторы		3.15. Оператор полигона

Разница между побитовыми и логическими операторами

Ключевая разница — побитовые

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

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

СОДЕРЖАНИЕ

1. Обзор и ключевые отличия
2. Что такое побитовые операторы
3. Что такое логические операторы
4. Сходства между побитовыми и логическими операторами
5. Сравнение бок о бок — побитовые и логические операторы в табличной форме 9представляет собой побитовое исключающее ИЛИ. ~ является дополнением. Символ << обозначает сдвиг влево, а символ >> — сдвиг вправо.

Побитовая операция И выглядит следующим образом. Когда x и y являются операндами, и x имеет значение 0, а y имеет значение 0, тогда побитовое И равно 0. Когда x равно 0, а y равно 1, то побитовое И равно 0. Если x равно 1, а y равно 0, тогда побитовое И равно 0. Когда и x, и y имеют 1, побитовое И равно 1. Выход будет 1, только если оба операнда содержат значение 1. Предположим, что 20 и 25 являются двумя значениями. Двоичное число 20 равно 10100. Двоичное число 25 равно 11001. Побитовое И этих двух чисел равно 10000. При выполнении побитовой операции И значение единица получается только тогда, когда оба операнда содержат единицу.

Операция побитового ИЛИ выглядит следующим образом. Когда x и y являются операндами, и x имеет значение 0, а y имеет значение 0, тогда побитовое ИЛИ равно 0. Когда x равно 0, а y равно 1, то выход равен 1. Когда x равен 1, а y равен 0, выход равно 1. Когда и x, и y имеют значение 1, выход равен 1. Из двух операндов, если один из операндов равен 1, то побитовое ИЛИ равно 1. Предположим, что 20 и 25 являются двумя значениями. Двоичное число 20 равно 10100. Двоичное число 25 равно 11001. Побитовое ИЛИ между 20 и 25 равно 11101.

Побитовое XOR даст 1, если оба значения различны. Когда операнды x и y равны нулю, тогда побитовое XOR равно 0. Когда x равно 0, а y равно 1, выход равен 1. Когда x равен 1, а y равен 0, тогда выход равен 1. Когда оба x и y равны 1, то на выходе будет 0. Побитовое XOR для 20 и 25 равно 01101. Символ ~ должен принимать дополнение к значению. Двоичное значение 20 равно 10100. Дополнение равно ~20 = 01011. Оно предназначено для преобразования единиц в нули и преобразования нулей в единицы.

<< — это бинарный оператор сдвига влево. Значение левого операнда перемещается влево на количество битов, указанное правым операндом. В примере 5 << 1 двоичное значение 5 равно 0101. 0101<<1 равно 1010. >> — это двоичный оператор сдвига вправо. Значение левого операнда сдвигается вправо на количество битов, указанное правым операндом. Например, 5 >> 1, 0101 >> 1 равно 0010.

Что такое логические операторы?

Логические операторы используются для принятия решения на основе нескольких условий. Символ && представляет собой логическое И. || символ представляет собой логическое ИЛИ. ! символ представляет собой логическое НЕ. В логическом И, если оба операнда отличны от нуля, условие становится истинным. В логическом ИЛИ, если оба операнда отличны от нуля, условие становится истинным. ! оператор может изменить логический статус операнда. Если условие истинно, то оператор логического НЕ сделает его ложным. Истина представляет значение 1, а ложно представляет значение 0.

Рисунок 01: Побитовые и логические операторы

Когда переменная x содержит значение 1, а переменная y содержит значение 0, логическое И, то есть (x && y), ложно или 0. (x || y) даст true или 1. Оператор NOT меняет логическое состояние на противоположное. Когда x имеет значение 1, тогда ! x равно 0. Когда y имеет значение 0, тогда !y равно 1.

В чем сходство между побитовыми и логическими операторами?

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

В чем разница между побитовыми и логическими операторами?

Побитовые и логические операторы
Побитовый оператор — это тип оператора, предоставляемого языком программирования для выполнения вычислений.	Логический оператор — это тип оператора, предоставляемого языком программирования для выполнения логических операций.
Функциональность
Побитовые операторы работают с битами и выполняют побитовые операции. 9, ~, <<, >>.	Логические операторы &&, \|\|, !

Резюме — побитовые

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

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

Штирлиц — Сеть печатных салонов в Перми

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

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

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

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

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

Вычисление по короткой схеме

Смешивание И и ИЛИ

Закон де Моргана

Где логический оператор исключающее ИЛИ (XOR)?

Небольшой тест

Теги

Логические операции and, or и not в Python.

Логические операторы стиля C (короткого замыкания) (Programming Perl)

Разница между побитовыми и логическими операторами

Ключевая разница — побитовые

СОДЕРЖАНИЕ

Что такое логические операторы?

В чем сходство между побитовыми и логическими операторами?

В чем разница между побитовыми и логическими операторами?

Побитовые и логические операторы

Резюме — побитовые

Добавить комментарий Отменить ответ