Espacios de nombres
Variantes
Acciones

Operadores lógicos

De cppreference.com
< cpp‎ | language

Devuelven el valor de una operación booleana.

Nombre operador Sintaxis Sobrecargable Ejemplos de prototipos (para class T)
Definición dentro de clase Definición fuera de clase
negación not a

!a

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

a && b

Si bool T::operator&&(const T2 &b) const; bool operator&&(const T &a, const T2 &b);
OR a or b

a || b

Si bool T::operator||(const T2 &b) const; bool operator||(const T &a, const T2 &b);
Notas
  • La forma con palabras (and,or,not) y las forma con símbolos (&&,||,!) se pueden usar indistintamente (ver representaciones alternativas)
  • Todos los operadores integrados devuelven bool, y muchas de las sobrecargas definidas por usuario también devuelven bool por lo que los operadores definidos por usuario se pueden usar de la misma manera que los integrados. Sin embargo, en la sobrecarga de operador definida por usuario, se puede usar cualquier tipo como tipo de retorno (incluyendo void).
  • Los operadores integrados && y || realizan una evaluación cortocircuitada (no evalua el segundo operando si se conoce el resultado después de evaluar el primero), pero los operadores sobrecargados funcionan como llamadas a funciones normales y siempre evalúan ambos operandos.

Contenido

[editar] Explicación

Las expresiones de operadores lógicos tienen la forma

! rhs (1)
lhs && rhs (2)
lhs || rhs (3)
1) NOT (no lógico)
2) AND (y lógico)
3) OR (o lógico)

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

El resultado es un bool prvalue.

Para el operador NOT lógico integrado, el resultado es true si el operando es false. En otro caso, el resultado es false.

Para el operador AND lógico integrado, el resultado es true si ambos operandos son true. En otro caso, el resultado es false. Este operado es cortocircuitado: si el primer operando es false, no se evalúa el segundo operando.

Para el operador OR lógico integrado, el resultado es true si el primer o el segundo operando (o ambos) es true. Este operador es cortocircuitado: si el primer operando es true, no se evalúa el segundo operando.

Tenga en cuenta que sobre los operadores lógicos sobre bits no se realiza cortocircuito.


[editar] 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 de operadores definidos por usuario, los siguientes modelos integrados de función participan en la resolución de sobrecarga:

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

[editar] Ejemplo

#include <iostream>
#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 "p &&"
       || !p &&  n != 2 ) // || tiene menos precedencia que &&
        std::cout << "verdadero\n";
 
    // los streams también son convertibles a bool
    std::cout << "Introduzca 'salir' para terminar.\n";
    for(std::string line;    std::cout << "> "
                          && std::getline(std::cin, line)
                          && line != "salir"; )
        ;
}

Salida:

verdadero
Introduzca 'salir' para terminar.
> test
> salir

[editar] Biblioteca estándar

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

aplica el operador aritmético unario a cada elemento del valarray
(función miembro público de std::valarray)
aplica operadores binarios a cada elemento de dos valarrays, o un valarray y un valor
(plantilla de función)
comprueba si ha ocurrido un error (sinónimo de fail())
Original:
checks if an error has occurred (synonym of fail())
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

(función miembro público de std::basic_ios) [editar]

[editar] Ver también

La precedencia de operadores

Precedencia de operadores

Sobrecarga de operadores

Operadores comunes
asignación incremento/decremento aritmético lógico comparación acceso a miembro otros

a = b
a = rvalue
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->b
a.b
a->*b
a.*b

a(...)
a, b
(type) a
? :

Operadores especiales

static_cast convierte de un tipo a otro tipo compatible
dynamic_cast convierte de clase base virtual a clase derivada
const_cast convierte de un tipo a otro compatible con diferentes calificadores constante/volátil
reinterpret_cast convierte el tipo a tipo incompatible
new asigna memoria
delete desasigna memoria
sizeof consulta el tamaño de un tipo
sizeof... consulta el tamaño de un parámetro de paquete (desde C++11)
typeid consulta la información de un tipo
noexcept comprueba si una expresión puede lanzar una excepción (desde C++11)
alignof consultas requisitos de alineación de un tipo (desde C++11)

Documentacion C de Operadores lógicos