Namespaces
Variants

Logical operators

From cppreference.net
C++
C++ language
General topics
Flow control
Conditional execution statements
Iteration statements (loops)
Jump statements
Functions
Function declaration
Lambda function expression
inline specifier
Dynamic exception specifications ( until C++17* )
noexcept specifier (C++11)
Exceptions
Namespaces
Types
Specifiers
constexpr (C++11)
consteval (C++20)
constinit (C++20)
Storage duration specifiers
Initialization
Expressions
Alternative representations
Literals
Boolean - Integer - Floating-point
Character - String - nullptr (C++11)
User-defined (C++11)
Utilities
Attributes (C++11)
Types
typedef declaration
Type alias declaration (C++11)
Casts
Memory allocation
Classes
Class-specific function properties
Special member functions
Templates
Miscellaneous
Expressions
General
Literals
Operators
Conversions

Devuelve el resultado de una operación booleana.

Nombre del operador Sintaxis Sobrecargable Ejemplos de prototipo (para class T )
Dentro de la definición de clase Fuera de la definición de clase
negación not a

! a

Sí bool T :: operator ! ( ) const ; bool operator ! ( const T & a ) ;
AND a and b

a && b

Sí bool T :: operator && ( const T2 & b ) const ; bool operator && ( const T & a, const T2 & b ) ;
OR inclusivo a or b

a || b

Sí bool T :: operator || ( const T2 & b ) const ; bool operator || ( const T & a, const T2 & b ) ;
Notas
  • Las formas similares a palabras clave ( and , or , not ) y las formas simbólicas ( && , || , ! ) pueden usarse indistintamente (ver representaciones alternativas ).
  • Todos los operadores incorporados retornan bool , y la mayoría de las sobrecargas definidas por el usuario también retornan bool para que los operadores definidos por el usuario puedan usarse de la misma manera que los incorporados. Sin embargo, en una sobrecarga de operador definida por el usuario, se puede usar cualquier tipo como tipo de retorno (incluyendo void ).
  • Los operadores incorporados && y || realizan evaluación de cortocircuito (no evalúan el segundo operando si el resultado se conoce después de evaluar el primero), pero los operadores sobrecargados se comportan como llamadas a funciones regulares y siempre evalúan ambos operandos.

Contenidos

Explicación

Las expresiones de operadores lógicos tienen la forma

! rhs (1)
lhs && rhs (2)
lhs || rhs (3)
1) NOT Lógico
2) AND lógico
3) OR lógico inclusivo

Si el operando no es bool , se convierte a bool usando conversión contextual a bool : solo está bien formado si la declaración bool t(arg) está bien formada, para algún t temporal inventado.

El resultado es un bool prvalue.

Para el operador lógico NOT incorporado, el resultado es true si el operando es false . De lo contrario, el resultado es false .

Para el operador lógico AND incorporado, el resultado es true si ambos operandos son true . De lo contrario, el resultado es false . Este operador es de evaluación de cortocircuito : si el primer operando es false , el segundo operando no se evalúa.

Para el operador lógico OR incorporado, el resultado es true si el primer operando o el segundo operando (o ambos) es true . Este operador tiene evaluación de cortocircuito: si el primer operando es true , el segundo operando no se evalúa.

Tenga en cuenta que los operadores lógicos bit a bit no realizan evaluación de cortocircuito.

Resultados

a true false
! a false true
and a
true false
b true true false
false false false
or a
true false
b true true true
false true false

En la resolución de sobrecarga frente a operadores definidos por el usuario , las siguientes firmas de función integradas participan en la resolución de sobrecarga:

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

Ejemplo

Ejecutar este código 
#include <iostream>
#include <sstream>
#include <string>
int main()
{
    int n = 2;
    int* p = &n;
    // los punteros son convertibles a bool
    if (    p && *p == 2  // "*p" es seguro de usar después de "p &&"
        || !p &&  n != 2) // || tiene menor precedencia que &&
        std::cout << "true\n";
    // los flujos también son convertibles a 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';
}

Salida: 

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

Biblioteca estándar

Debido a que las propiedades de cortocircuito de operator&& y operator|| no se aplican a las sobrecargas, y debido a que los tipos con semántica booleana son poco comunes, solo dos clases de la biblioteca estándar sobrecargan estos operadores:

aplica un operador aritmético unario a cada elemento del valarray
(función miembro pública de std::valarray<T> )
aplica operadores binarios a cada elemento de dos valarrays, o un valarray y un valor
(plantilla de función)
verifica si ha ocurrido un error (sinónimo de fail() )
(función miembro pública de std::basic_ios<CharT,Traits> )

Véase también

Precedencia de operadores

Sobrecarga de operadores

objeto función que implementa x && y
(plantilla de clase)
objeto función que implementa x || y
(plantilla de clase)
objeto función que implementa ! x
(plantilla de clase)
Operadores comunes
asignación incremento
decremento 		aritméticos lógicos comparación acceso a
miembros 		otros

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

llamada a función

a ( ... )
coma

a, b
condicional

a ? b : c
Operadores especiales

static_cast convierte un tipo a otro tipo relacionado
dynamic_cast convierte dentro de jerarquías de herencia
const_cast añade o elimina cv -calificadores
reinterpret_cast convierte un tipo a un tipo no relacionado
Conversión estilo C convierte un tipo a otro mediante una mezcla de static_cast , const_cast , y reinterpret_cast
new crea objetos con duración de almacenamiento dinámico
delete destruye objetos previamente creados por la expresión new y libera el área de memoria obtenida
sizeof consulta el tamaño de un tipo
sizeof... consulta el tamaño de un pack (desde C++11)
typeid consulta la información de tipo de un tipo
noexcept verifica si una expresión puede lanzar una excepción (desde C++11)
alignof consulta los requisitos de alineación de un tipo (desde C++11)

Documentación de C para Operadores lógicos