Una operación lógica utiliza como operandos datos booleanos. La mayoría de ellas compara dos expresiones o datos booleanos y indica una posibilidad de lo que puede ocurrir cuando se juntan. El resultado es otra expresión booleana.

En la pagina anterior hemos visto las operaciones condicionales, las cuales daban como resultado expresiones booleanas. Por lo tanto también podemos poner como operandos de las operaciones lógicas el resultado de una operación condicional. Es decir, cada uno de los operandos es una operación condicional, la cual se realiza en primer lugar, para después realizar las operación lógica.

Sin embrago entenderemos esto mas fácilmente cuando veamos cuales son las operaciones lógicas.

Operador AND

Esta operación compara dos datos booleanos, de manera que el resultado sera "true" (verdadero) solamente si los dos operandos son "true" (verdadero); en los demás casos el resultado sera "false" (falso).

El signo para realizar la operación es && (doble signo ampersand) pero también podemos poner la palabra and. Por ejemplo, declaramos las siguientes variables booleanas.

bool v1=true, v2=true, f1=false, f2=false, r;

Las variables que tenemos inicializadas las utilizaremos como operandos, mientras que la variable r, sin inicializar, sera donde obtengamos el resultado, operamos así:

r = v1 && v2;

El resultado sera true. La misma operación la podemos escribir así:

r = v1 and v2;

Aunque es preferible ponerlo como en el primer ejemplo.

Los posibles valores que puede tener el resultado son los siguientes:

r = v1 && v2; // r: true

r = v1 && f1; // r: false

r = f1 && v1; // r: false

r = f1 && f2; // r: false

Aqui el resultado solo es verdadero si los dos operandos son verdaderos.

Operador OR

Este operador compara dos datos booleanos, de manera que el resultado sera "false" (falso) solamente si los dos operadores son falsos; en los demás casos el resultado es "true" (verdadero).

El signo para realizar la operación consiste en la doble barra vertical || (en la mayoría de los teclados se escribe con las teclas "Alt Gr" + 1). También tenemos lam opción de escribir la palabra or entre los operandos.

Los posibles valores que puede tener el resultado son los siguientes: (utilizaremos aquí las mismas variables que en el ejemplo con and)

r = v1 || v2; // r: true

r = v1 || f1; // r: true

r = f1 || v1; // r: true

r = f1 || f2; // r: false

Aquí el resultado solo es falso si los dos operandos son falsos.

Operador NOT

Este es un operador unario, es decir se aplica a un solo elemento que sera un dato booleano, y lo que hace es cambiarlo de valor. De manera que si el dato es verdadero el resultado es falso, y si el dato es falso, el resultado es verdadero.

El operando es un signo de admiración puesto delante del dato o variable que contiene el dato. Siguiendo con las mismas variables de ejemplos anteriores.

r = !v1; // r: false

r = !f1; // r: true

Aquí el resultado siempre es el contrario del que tenemos al principio.

Operador XOR

Este operador compara dos variables booleanas, y devuelve true cuando una de las dos es verdadera true y la otra falsa false. Cuando las dos son verdaderas, o las dos son falsas devuelve false.

El signo del operador es el acento circunflejo ^ , aunque también podemos escribir la palabra xor entre los dos operandos (El acento circunflejo lo escribimos con mayascula + acento grave, y después la barra espaciadora).

Los posibles valores que puede tener el resultado son los siguientes: (utilizaremos aquí las mismas variables que en ejemplos anteriores)

r = v1 xor v2; // r: false

r = v1 xor f1; // r: true

r = f1 xor v1; // r: true

r = f1 xor f2; // r: false

Aqui el resultado es falso cuando los dos operandos son iguales, y verdadero cuando son contrarios.

Operador condicional ternario

Este operador utiliza tres operandos, el primero es siempre un dato o expresión booleana. El segundo y el tercero pueden ser datos de cualquier otro tipo, siempre que los dos sean del mismo tipo. Supongamos que declaramos las siguientes variables:

bool tr=true, fs=false;

string vr="verdad", mt="mentira", resultado;

Ahora utilizamos el operador condicional ternario. Lo escribiremos asi:

resultado = tr ? vr : mt;

El primer operando es tr que es un booleano, el segundo y el tercero aquí son strings, pero pueden ser datos de cualquier otro tipo, siempre que los dos sean del mismo tipo. El resultado sera el segundo operando siempre que el booleano del primero sea true, y el tercero cuando el booleano sea false. En el ejemplo anterior recogemos el resultado en la variable resultado.

Si seguimos el ejemplo anterior, se puede comprobar mostrando el resultado en pantalla:

cout << resultado << endl;

El resultado al compilar y ejecutar, dará la palabra "verdad". Si cambiamos el primer operando (variable tr) por la variable fs, veremos que el resultado es la palabra "mentira".

Programa con operadores lógicos

Vamos a hacer un programa en el que vemos como funcionan los operadores lógicos. El programa es el siguiente:

PRUEBA TU MISMO!!! http://cpp.sh/7x7sv

Al compilar y ejecutar el programa, este se abre y pide al usuario que introduzca dos booleanos. este escribe los booleanos en forma de 0 y 1, y después se realizan las operaciones lógicas con los mismos.

Observa en el código fuente como realizamos las operaciones "and", "or", "xor" y "not", y luego utilizamos el operador condicional ternario para indicar si los operandos son verdaderos o falsos.

El uso de paréntesis es necesario para delimitar las operaciones, de manera que así se indica que esta es un todo del cual se debe mostrar el resultado.