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

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

Имя оператора	Синтаксис	Перегружаемый	Примеры прототипов (для `class T`)
Имя оператора	Синтаксис	Перегружаемый	Внутри определения класса	Вне определения класса
отрицание	`not a` `!a`	Да	`bool T::operator!() const;`	`bool operator!(const T &a);`
И	`a and b` `a && b`	Да	`bool T::operator&&(const T2 &b) const;`	`bool operator&&(const T &a, const T2 &b);`
включающее ИЛИ	`a or b` `a \|\| b`	Да	`bool T::operator\|\|(const T2 &b) const;`	`bool operator\|\|(const T &a, const T2 &b);`
Примечания Формы, похожие на ключевые слова (`and`,`or`,`not`), и символьные формы (`&&`,`\|\|`,`!`) взаимозаменяемы (см. альтернативные представления). Все встроенные операторы возвращают `bool`, и большинство пользовательских перегрузок также возвращают `bool`, чтобы пользовательские операторы можно было использовать так же, как встроенные. Однако в пользовательской перегрузке оператора в качестве возвращаемого типа можно использовать любой тип (включая `void`). Встроенные операторы `&&` и `\|\|` выполняют вычисление с коротким замыканием (не вычисляют второй операнд, если результат известен после вычисления первого), тогда как перегруженные операторы ведут себя как обычные вызовы функций и всегда вычисляют оба операнда.

Пояснение

Логические выражения имеют следующий вид:

`!` rhs	(1)
lhs `&&` rhs	(2)
lhs `\|\|` rhs	(3)

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

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

3) Логическое включающее ИЛИ

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

Результат имеет тип bool prvalue.

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

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

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

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

Результаты

`a`	`true`	`false`
`!a`	`false`	`true`

`and`		`a`
`and`		`true`	`false`
`b`	`true`	`true`	`false`
`b`	`false`	`false`	`false`

`or`		`a`
`or`		`true`	`false`
`b`	`true`	`true`	`true`
`b`	`false`	`true`	`false`

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

bool operator!(bool)
bool operator&&(bool, bool)
bool operator\|\|(bool, bool)

Пример

#include <iostream>
#include <sstream>
#include <string>

int main()
{
    int n = 2;
    int* p = &n;
    // pointers are convertible to bool
    if (    p && *p == 2  // "*p" is safe to use after "p &&"
        || !p &&  n != 2) // || has lower precedence than &&
        std::cout << "true\n";

    // streams are also convertible to bool
    std::stringstream cin;
    cin << "3...\n" << "2...\n" << "1...\n" << "quit";
    std::cout << "Enter 'quit' to quit.\n";
    for (std::string line;    std::cout << "> "
                           && std::getline(cin, line)
                           && line != "quit";)
        std::cout << line << '\n';
}

Вывод:

true
Enter 'quit' to quit.
> 3...
> 2...
> 1...
>

Стандартная библиотека

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

operator!	применяет унарный арифметический оператор к каждому элементу valarray (открытая функция-член `std::valarray<T>`)
operator&&operator	применяет бинарные операторы к каждому элементу двух valarray либо valarray и значения (шаблон функции)
operator!	проверяет, произошла ли ошибка (синоним `fail()`) (открытая функция-член `std::basic_ios<CharT,Traits>`)

См. также

Приоритет операторов

Перегрузка операторов

logical_and	функциональный объект, реализующий `x && y` (шаблон класса)
logical_or	функциональный объект, реализующий `x \|\| y` (шаблон класса)
logical_not	функциональный объект, реализующий `!x` (шаблон класса)

Распространённые операторы
Присваивание	Инкремент, декремент	Арифметические	Логические	Сравнение	Доступ к членам	Другие
a = b a += b a -= b a *= b a /= b a %= b a &= b a \|= b a ^= b a <<= b a >>= b	++a --a a++ a--	+a -a a + b a - b a * b a / b a % b ~a a & b a \| b a ^ b a << b a >> b	!a a && b a \|\| b	a == b a != b a < b a > b a <= b a >= b a <=> b	a[...] a &a a->b a.b a->b a.*b	вызов функции `a(...)`
						запятая `a, b`
						условный `a ? b : c`
Специальные операторы
`static_cast` преобразует один тип в другой связанный тип `dynamic_cast` выполняет преобразование в иерархиях наследования `const_cast` добавляет или удаляет квалификаторы cv `reinterpret_cast` преобразует тип в несвязанный тип Приведение в стиле C преобразует один тип в другой с помощью комбинации static_cast, const_cast и reinterpret_cast `new` создаёт объекты с динамической длительностью хранения `delete` уничтожает объекты, ранее созданные выражением new, и освобождает полученную область памяти `sizeof` запрашивает размер типа `sizeof...` запрашивает размер пакета (начиная с C++11) `typeid` запрашивает информацию о типе `noexcept` проверяет, может ли выражение выбросить исключение (начиная с C++11) `alignof` запрашивает требования к выравниванию типа (начиная с C++11) `^^` создаёт значение отражения на основе грамматической конструкции (начиная с C++26)

Документация по C для логических операторов

© cppreference.com
Licensed under the Creative Commons Attribution-ShareAlike Unported License v3.0.
https://en.cppreference.com/cpp/language/operator_logical