Operadores lógicos

De EcuRed
Operadores lógicos
Información sobre la plantilla
Concepto:Nos proporcionan un resultado a partir de que se cumpla o no una cierta condición, producen un resultado booleano, y sus operandos son también valores lógicos o asimilables a ello

Operadores lógicos. Muy utilizados en Informática, Lógica proposicional y Álgebra booleana, entre otras disciplinas. Los operadores lógicos nos proporcionan un resultado a partir de que se cumpla o no una cierta condición, producen un resultado booleano, y sus operandos son también valores lógicos o asimilables a ellos (los valores numéricos son asimilados a cierto o falso según su valor sea cero o distinto de cero). Esto genera una serie de valores que, en los casos más sencillos, pueden ser parametrizados con los valores numéricos 0 y 1. La combinación de dos o más operadores lógicos conforma una función lógica.

Los operadores lógicos son tres; dos de ellos son binarios, el último (negación) es unario. Tienen una doble posibilidad de representación en el estándar C++ actual: la representación tradicional que se indica a continuación, y la natural introducida recientemente que se detalla más adelante.

  • Y lógico && AND
  • O lógico || OR
  • Negación lógica  ! NOT

Las expresiones conectadas con los operadores && y || se evalúan de izquierda a derecha, y la evaluación se detiene tan pronto como el resultado verdadero o falso es conocido (muchos programas tienen una lógica que se basa en este propiedad).

Contenido

Operador Y lógico (&&)

También denominado por su nombre en inglés (generalmente en mayúsculas) AND lógico. Devuelve un valor lógico true si ambos operandos son ciertos. En caso contrario el resultado es false.

Sintaxis

  expr-AND-logica && expresion-OR-inclusive

Comentario:

La operatoria es como sigue: El primer operando (de la izquierda) es convertido a bool. Para ello, si es una expresión, se evalúa para obtener el resultado (esta computación puede tener ciertos efectos laterales). A continuación, el valor obtenido es convertido a bool cierto/falso siguiendo las reglas de conversión estándar. Si el resultado es false, el proceso se detiene y este es el resultado, sin que en este caso sea necesario evaluar la expresión de la derecha (recuérdese que en el diseño de C++ prima la velocidad).

Si el resultado del operando izquierdo es cierto, se continúa con la evaluación de la expresión de la derecha, que también es convertida a bool. Si el nuevo resultado es true, entonces el resultado del operador es true. En caso contrario el resultado es false.

Ejemplo:

  int m[3] = {0,1,2};
  int x = 0;
  if (m && x) cout << "Cierto.";
  else cout << "Falso.";
  Salida:
  Falso.

El valor m, que es interpretado como un puntero al primer elemento de la matriz, es transformado a un bool. Como es distinto de cero (no es un puntero nulo) el resultado es cierto. A continuación, el valor x es convertido también a bool. En este caso la conversión produce falso, con lo que este es el resultado del paréntesis de la sentencia if. Ejemplo:

  #include <iostream.h>
  bool alto = true, bajo = false, blanco = true, negro = false;
  int main (void) {
    if (alto && bajo) { cout << "Uno cierto" << endl; }
    else cout << "Uno falso" << endl;
    if (alto && blanco) { cout << "Dos cierto" << endl; }
    else cout << "Dos falso" << endl;
    if (bajo && negro) { cout << "Tres cierto" << endl; }
    else cout << "Tres falso" << endl;
  }
Salida:
  Uno falso
  Dos cierto
  Tres falso

Operador O lógico (||)

Este operador binario devuelve true si alguno de los operandos es cierto. En caso contrario devuelve false.

Sintaxis

expr-OR-logica || expresion-AND-logica

Comentario

Este operador sigue un funcionamiento análogo al anterior. El primer operando (izquierdo) es convertido a bool. Para ello, si es una expresión, se evalúa para obtener el resultado (esta computación puede tener ciertos efectos laterales). A continuación el valor obtenido es convertido a bool cierto/falso siguiendo las reglas de conversión estándar. Si el resultado es true, el proceso se detiene y este es el resultado, sin que en este caso sea necesario evaluar la expresión de la derecha (recuérdese que en el diseño de C++ prima la velocidad).

Si el resultado del operando izquierdo es false, se continúa con la evaluación de la expresión de la derecha, que también es convertida a bool. Si el nuevo resultado es true, entonces el resultado del operador es true. En caso contrario el resultado es false.

Ejemplo

  #include <iostream.h>
  bool alto = true, bajo = false, blanco = true, negro = false;
  int main (void) {
    if (alto || bajo) { cout << "Uno cierto" << endl; }
    else cout << "Uno falso" << endl;
    if (alto || blanco) { cout << "Dos cierto" << endl; }
    else cout << "Dos falso" << endl;
    if (bajo || negro) { cout << "Tres cierto" << endl; }
    else cout << "Tres falso" << endl;
  }
Salida
  Uno cierto
  Dos cierto
  Tres falso

Operador NO lógico: ( !)

Este operador es denominado también negación lógica y se representa en el texto escrito por la palabra inglesa NOT (otros lenguajes utilizan directamente esta palabra para representar el operador en el código).

Sintaxis

  ! expresion-cast

Comentario

El operando expresion-cast (que puede ser una expresión que se evalúa a un resultado es convertido a tipo bool, con lo que solo puede ser uno de los valores cierto/falso. A continuación el operador cambia su valor: Si es cierto es convertido a falso y viceversa.

Resulta por tanto, que el resultado de este operador es siempre un tipo bool, aunque al existir una conversión estándar por la que un cero es convertido a false, y cualquier valor distinto de cero a true, coloquialmente se dice que este operador convierte un operando 0 en 1 y uno no-cero en 0. En otras palabras: este operador devuelve cierto (true) si la expresión se evalúa a distinto de cero, en caso contrario devuelve falso (false).

Ejemplo

  #include <iostream.h>
  bool alto = true, bajo = false;
  int main (void) {
    if (alto) { cout << "Uno cierto" << endl; }
    else cout << "Uno falso" << endl;
    if (!alto) { cout << "Dos cierto" << endl; }
    else cout << "Dos falso" << endl;
    if (!bajo) { cout << "Tres cierto" << endl; }
    else cout << "Tres falso" << endl;
  }
Salida:
  Uno cierto
  Dos falso
  Tres cierto

Representación explícita

Los operadores lógicos entre valores lógicos &&, ||, !; la relación de desigualdad !=; algunos de los operadores lógicos entre bits (&, |, ^, ~) y sus expresiones compuestas (&=, |=, ^=), tienen una representación realmente difícil de leer, con la desventaja adicional que sus símbolos no siempre están fácilmente accesibles en ordenadores con teclados distintos del estándar USA. Para resolver este problema, el estándar C++ ha introducido nuevas formas para su representación; las denominamos formas explícitas o naturales, en razón de que se parecen más a las palabras correspondientes del lenguaje natural. Las nuevas formas constituyen palabras-clave, y la tabla de equivalencias es la siguiente:

Palabra clave Símbolo Descripción
and && Operador Y lógico
or / Operador O lógico
not  ! Operador negación lógica
bitand & Operador AND entre bits
xor ^ Operador OR exclusivo entre bits
bitor / Operador OR inclusivo entre bits
compl ~ Operador complemento a uno de bits
and_eq &= Asignación compuesta (AND entre bits)
xor_eq ^= Asignación compuesta (XOR entre bits)
or_eq = Asignación compuesta (OR entre bits)
not_eq  != Operador relacional de desigualdad

Véase también

Fuente