Operadores relacionales lógicos¶

Sirven para evaluar expresiones compuestas de tipo lógico, cuya resultado, por tanto, resultará cierto o falso, true o false.

La evaluación de las operaciones lógicas se realiza de izquierda a derecha y se interrumpe cuando se ha asegurado el resultado. Esto se conoce como propiedad de cortocircuito: si se puede concluir el valor lógico del resultado a partir de una evaluación parcial de la expresión, no se sigue evaluando la misma.

Operadores relacionales lógicos¶
Operador	Descripción
`&&`	Y, devuelve `true` cuando todas las expresiones que relaciona son ciertas
`\|\|`	O, devuelve `true` cuando al menos una expresión es cierta
`!`	NO, devuelve `true` cuando la expresión a la que afecta es `false`

Las tablas de verdad asociadas a estos operadores son:

Operador **Y lógico**¶
`a`	`b`	`a && b`
`false`	`false`	`false`
`false`	`true`	`false`
`true`	`false`	`false`
`true`	`true`	`true`

Operador **O lógico**¶
`a`	`b`	`a \|\| b`
`false`	`false`	`false`
`false`	`true`	`true`
`true`	`false`	`true`
`true`	`true`	`true`

Operador **NO lógico**¶
`a`	`!a`
`false`	`true`
`true`	`false`

Los operadores de comparación y lógicos aparecen habitualmente de forma simultánea en las expresiones. Por ello, es conveniente conocer su orden de precedencia relativo:

Tabla de precedencia de los operadores de comparación y lógicos¶
Precedencia	Operador	Descripción	Asociatividad
3	`!`	Negación lógica	Izquierda a derecha
9	`<` `<=` `>` `>=`	Operadores de comparación	Izquierda a derecha
10	`==` `!=`	Operadores de igualdad	Izquierda a derecha
14	`&&`	Conjunción lógica	Izquierda a derecha
15	`\|\|`	Disyunción lógica	Izquierda a derecha

Insistimos en usar los paréntesis (...) en caso de duda y/o para mejorar la legibilidad.

Ejemplo 1

// Ejemplo que controla el rango permitido de valores de dos enteros
#include <iostream>
using namespace std;

int main()
{
   int x, y;
   cout << "Introduce dos números enteros positivos o 0. "
         << "Ambos no pueden valer simultáneamente 0.\n";
   cout << "Introduce el primer número: ";
   cin >> x;
   cout << "Introduce el segundo número: ";
   cin >> y;

   if (x < 0 || y < 0)
      cout << "Error. Los números introducidos no son ambos positivos.\n";
   else if (x == 0 && y == 0)
      cout << "Error. Los dos números son 0.\n";
   else
      cout << "Los números introducidos son validos.\n";
}

Edita, compila y ejecuta el código

Nótese la superior precedencia de los operadores de comparación respecto a los lógicos && y || en expresiones como x < 0 || y < 0 o x == 0 && y == 0.

Por la propiedad de cortocircuito, en el ejempo anterior, si el usuario introduce cualquier valor de x negativo, no se evaluará la expresión y < 0.

Ejemplo 2

// Ejemplo que controla que un denominador no sea 0
#include <iostream>
using namespace std;

int main()
{
   int x, y;
   cout << "Introduce el numerador: ";
   cin >> x;
   cout << "Introduce el denominador: ";
   cin >> y;

   if (!y)  // Equivalente a if (y == 0)
      cout << "Error. No podemos dividir por 0.\n";
   else
      cout << "x/y= " << x/y << endl;
}

Edita, compila y ejecuta el código

Este ejemplo nos permite recordar que el operador división / entre enteros genera un entero.