Espacios de nombres
Variantes
Acciones

Operadores lógicos

De cppreference.com
< cpp‎ | language
 
C++
Apoyo de compiladores
Implementaciones independientes y albergadas
Lenguaje
Biblioteca estándar
Encabezados de la biblioteca estándar
Requisitos denominados
Macros de prueba de característica (C++20)
Biblioteca de apoyo del lenguaje
Biblioteca de conceptos (C++20)
Biblioteca de diagnósticos
Biblioteca de gestión de memoria
Biblioteca de metaprogramación (C++11)
Biblioteca de servicios generales
Biblioteca de contenedores
Biblioteca de iteradores
Biblioteca de rangos (C++20)
Biblioteca de algoritmos
Biblioteca de cadenas
Biblioteca de procesamiento de texto
Biblioteca numérica
Biblioteca de fecha y hora
Biblioteca de entrada/salida
Biblioteca del sistema de archivos (C++17)
Biblioteca de apoyo de concurrencia (C++11)
Biblioteca de apoyo de ejecución (C++26)
Especificaciones técnicas
Índice de símbolos
Bibliotecas externas
 
Lenguaje C++
 
Expresiones
General
Literales
Operadores
Conversiones
 

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

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 a or b

a || b

Sí 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

Ejecuta este código
#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ública de std::valarray)
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>) [editar]

[editar] Ver también

La precedencia de operadores

Precedencia de operadores

Sobrecarga de operadores

Operadores comunes
Asignación Incremento/decremento Aritméticos Lógicos Comparación Acceso a miembro 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[b]
*a
&a
a->b
a.b
a->*b
a.*b

a(...)
a, b
? :

Operadores especiales

static_cast Convierte de un tipo a otro tipo relacionado
dynamic_cast Convierte dentro de jerarquías de herencia
const_cast Añade o suprime los calificadores const/volatile
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ámica
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 paquete de parámetros (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 Consulta requisitos de alineación de un tipo (desde C++11)

Documentación de C para Operadores lógicos
Obtenido de «https://es.cppreference.com/mwiki/index.php?title=cpp/language/operator_logical&oldid=32515»