C Language Operadores logicos


Ejemplo

Y lógico

Realiza un AND lógico booleano de los dos operandos que devuelven 1 si ambos operandos son distintos de cero. El operador lógico AND es de tipo int .

0 && 0  /* Returns 0. */
0 && 1  /* Returns 0. */
2 && 0  /* Returns 0. */
2 && 3  /* Returns 1. */

O lógico

Realiza un OR lógico booleano de los dos operandos que devuelven 1 si alguno de los operandos no es cero. El operador lógico OR es de tipo int .

0 || 0  /* Returns 0. */
0 || 1  /* Returns 1.  */
2 || 0  /* Returns 1.  */
2 || 3  /* Returns 1.  */

Lógica NO

Realiza una negación lógica. El operador lógico NOT es de tipo int . El operador NO verifica si al menos un bit es igual a 1, si es así devuelve 0. En caso contrario, devuelve 1;

!1 /* Returns 0. */
!5 /* Returns 0. */
!0 /* Returns 1. */

Evaluación de corto circuito

Hay algunas propiedades cruciales comunes a && y || :

  • el operando de la izquierda (LHS) se evalúa completamente antes de que se evalúe el operando de la derecha (RHS),
  • hay un punto de secuencia entre la evaluación del operando de la izquierda y el operando de la derecha,
  • y, lo más importante, el operando de la derecha no se evalúa en absoluto si el resultado del operando de la izquierda determina el resultado general.

Esto significa que:

  • si el LHS se evalúa como 'verdadero' (distinto de cero), el RHS de || no se evaluará (porque el resultado de "verdadero O cualquier cosa" es "verdadero"),
  • si el LHS se evalúa como "falso" (cero), el RHS de && no se evaluará (porque el resultado de "falso Y cualquier cosa" es "falso").

Esto es importante ya que le permite escribir código como:

const char *name_for_value(int value)
{
    static const char *names[] = { "zero", "one", "two", "three", };
    enum { NUM_NAMES = sizeof(names) / sizeof(names[0]) };
    return (value >= 0 && value < NUM_NAMES) ? names[value] : "infinity";
}

Si se pasa un valor negativo a la función, el value >= 0 término se evalúa como falso y el value < NUM_NAMES term no se evalúa.