Para Arduino

AND (&&)

El operador && (AND) es binario (necesita 2 operandos) y devuelve valor true cuando los dos operandos tienen valor true.

En cualquier otro caso devuelve false, es decir, cuando uno de los dos operandos o los dos tienen valor false.

En la siguiente tabla puedes ver cómo se evalúa una expresión con este operador:

Ejemplos

Vamos a ver un ejemplo de código muy sencillo:

bool x = true;
bool y = true;
bool resultado = x && y;

He replicado uno de los casos que hay en la tabla. Los dos operandos, en este caso son variables bool (x e y), tienen valor true. Como los dos son true, ¿Qué valor tendrá la variable resultado? Exacto, será true.

Vamos con otro ejemplo un poco más complejo:

int a = 5;
int b = 10;
bool resultado = (a < b) && ((a * 2) == 10);

La expresión se ha complicado un poco, ¿Qué crees que devolverá el operador && en este caso?

Vamos a evaluarlo por partes. Los paréntesis siempre lo primero:

• (a < b): La variable a tiene valor 5 y la variable b tiene valor 10, por lo que la expresión es cierta, así que este paréntesis es true.
• ((a * 2) == 10): Aquí tenemos, por un lado una multiplicación (a * 2) y por otro una comparación de igualdad (==). La multiplicación vale 10 porque la variable a tiene valor 5 y lo estamos multiplicando por 2. El resultado de la multiplicación es lo que comparamos con el 10 en la igualdad (10 == 10). Por tanto, el resultado final de la expresión es true.

Como ya tenemos el valor del primer operando (a < b) y del segundo (((a * 2) == 10)), aplicar el operador && es muy sencillo. Ambos operandos son true, por lo que el operador && devolverá true. Fácil, ¿no?

OR (||)

El operador lógico || (OR) en Arduino es también binario y devuelve valor true cuando al menos uno de los dos operadandos implicados en la expresión es true. Y digo al menos, porque con que uno sea true es suficiente, pero si los dos lo son también devuelve true.

Este operador solo devuelve false cuando los dos operandos son false.

Mira en la siguiente tabla cómo se evalúa el operador ||:

Ejemplos

Primer ejemplo:

bool x = true;
bool y = false;
bool resultado = x || y;

El primer operando, en este ejemplo, es la variable x, que tiene valor true. El segundo operando es la variable y que tiene valor false. Como el operador OR(||) solo necesita que uno de los dos sea true para ser cierto (en este caso se cumple), el resultado final será true. Es más, como el primer operando (x) es true, ya no evaluará el segundo (y) porque no variará el resultado.

Muy fácil, vamos a ver otro ejemplo más complejo:

int a = 5;
int b = 10;
bool resultado = (a > b) || (b == 10);

En este caso el operador || evalúa dos operandos que son a su vez dos expresiones, vamos a analizarlas por separado:

• (a > b): La variable a tiene valor 5 y la variable b tiene valor 10. No es cierto que 5 sea mayor que (>) 10, por lo que el resultado de esta expresión es false.
• (b == 10): La variable b tiene valor 10, que es justo el valor con el que se está haciendo la comparación de igualdad (==), por lo que el resultado de esta expresión es true.

La evaluación del primer operando (a > b) es false, por lo que es necesario evaluar el segundo. El segundo operando (b == 10) si es true, por lo que el resultado final del operador || será true.

NOT (!)

El último operador lógico de la lista es el operador ! (NOT).

Al contrario que los anteriores, el operador ! es unario, es decir, solo se utiliza con un operando.

El operador ! niega el valor bool del operando al que afecta. Esto significa que devuelve el valor opuesto. Si el operando tiene valor true devolverá false y cuando el operando sea false devolverá true.

Míralo en la siguiente tabla para entenderlo mejor:

Ejemplos

El siguiente ejemplo es muy sencillo, pero lo vas a entender perfectamente:

bool a = true;
bool resultado = !a;

La variable a tiene valor true y al aplicar el operador ! el valor devuelto como resultado será el opuesto, es decir, false. No tiene mucho misterio.

Vamos a ver un ejemplo un poco más complejo:

int a = 5;
int b = 10;
bool resultado = !((a * 2) > b);

Si te fijas, el operador ! afecta a todo el paréntesis exterior, por tanto, debemos evaluar el valor del paréntesis para obtener el opuesto.

Dentro del paréntesis hay una comparación de mayor exclusivo (>). El primer operando de esta comparación es una multiplicación (a * 2). Como está entre paréntesis haremos eso primero:

• (a * 2): El resultado de esta operación es 10, porque la variable a tiene valor 5.
• ((a * 2) > b): Como ya sabemos el resultado de la multiplicación, podemos compararlo con b, que tiene valor 10. No es cierto que 10 sea mayor exclusivo que 10, por lo tanto el resultado de esta expresión es false.

Ahora que ya sabemos el valor del paréntesis (false), podemos aplicar el operador not: !((a * 2) > b). El resultado es el opuesto, es decir, true.