Devuelve el resultado de una operación booleana.

Nombre del operador Sintaxis Sobrecarga capaz Ejemplos de prototipos (para class T)
Definición de clase interna Definición de clase externa
negación not a

!a.

 sí bool T::operator!() const; bool operator!(const T &a);
Y a and b

a && b.

 sí bool T::operator&&(const T2 &b) const; bool operator&&(const T &a, const T2 &b);
inclusive O 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 (&&,||,!) se puede usar indistintamente (ver representaciones alternativas)
  • Todos los operadores incorporados regresan bool, y la mayoría de las sobrecargas definidas por el usuario también devuelven bool para que los operadores definidos por el usuario se puedan utilizar de la misma manera que los integrados. Sin embargo, en una sobrecarga de operador definida por el usuario, cualquier tipo se puede utilizar como tipo de retorno (incluido void).
  • Operadores integrados && y || realizar una evaluación de cortocircuito (no evaluar el segundo operando si se conoce el resultado después de evaluar el primero), pero los operadores sobrecargados se comportan como llamadas de función regulares y siempre evalúan ambos operandos

Explicación

Las expresiones del operador lógico tienen la forma.

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

1) NO lógico2) Y lógico3) OR lógico inclusivo

Si el operando no es bool, se convierte en bool usando la conversión contextual para bool: solo está bien formado si la declaración bool t(arg) está bien formado, para algunos inventados temporales t.

El resultado es un bool prvalue.

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

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

Para el operador OR lógico incorporado, el resultado es true si el primer o el segundo operando (o ambos) es true. Este operador está en 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 cortocircuitos.

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 contra operadores definidos por el usuario, las siguientes firmas de funciones integradas participan en la resolución de sobrecarga:

booloperator!(bool)
 
booloperator&&(bool,bool)
 
booloperator||(bool,bool)

Ejemplo

#include#includeintmain()!p &&  n !=2)//

Producción:

true
Enter 'quit' to quit.> test
> quit

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 biblioteca estándar sobrecargan estos operadores:

¡operador! aplica un operador aritmético unario a cada elemento del valarray
(función de miembro público de std::valarray)
operador&&operador || aplica operadores binarios a cada elemento de dos valarray, o un valarray y un valor
(plantilla de función)
¡operador! comprueba si ha ocurrido un error (sinónimo de fail())
(función de miembro público de std::basic_ios)

Ver también

Precedencia del operador.

Sobrecarga del operador.

Operadores comunes
asignación incremento
decremento		 aritmética lógico comparación miembro
acceso		 otro

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[b] *a &a a->b a.b a->*b a.*b.

a(...) a, b ? :
Operadores especiales

static_cast convierte un tipo en otro tipo relacionado
dynamic_cast convierte dentro de las jerarquías de herencia
const_cast agrega o elimina calificadores de cv
reinterpret_cast convierte el tipo en un tipo no relacionado
El elenco de estilo C convierte un tipo en otro mediante una mezcla de static_cast, const_cast, y reinterpret_cast
new crea objetos con una duración de almacenamiento dinámica
delete destruye objetos previamente creados por la nueva expresión y libera el área de memoria obtenida
sizeof consulta el tamaño de un tipo
sizeof... consulta el tamaño de un paquete de parámetros(desde C ++ 11)
typeid consulta la información de tipo de un tipo
noexcept comprueba si una expresión puede lanzar una excepción (desde C ++ 11)
alignof requisitos de alineación de consultas de un tipo (desde C ++ 11).