Operadores lógicos
| ||||||
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).
Sumario
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
- Operadores
- Operadores aritméticos
- Operadores de manejo de bits
- Operador condicional
- Operador coma
- Operadores relacionales
- Operadores de asignación
- Operadores de modelado de tipos
- Operadores añadidos a expresión
- Operador de acceso a ámbito
- Operadores de puntero
- Operador new
- Operador new con matrices
- Operador delete
- Operador sizeof
- Operador typeid
- Operador de preproceso
