Namespaces
Variants

Logical operators

From cppreference.net
C
C language
Expressions

Los operadores lógicos aplican operaciones estándar de álgebra booleana a sus operandos.

Operador Nombre del operador Ejemplo Resultado
! NOT lógico ! a la negación lógica de a
&& AND lógico a && b el AND lógico de a y b
|| OR lógico a || b el OR lógico de a y b

Contenidos

NOT lógico

La expresión NOT lógica tiene la forma

! expresión

donde

expression - una expresión de cualquier tipo escalar

El operador lógico NOT tiene tipo int . Su valor es ​ 0 ​ si expression se evalúa a un valor que compara desigual a cero. Su valor es 1 si expression se evalúa a un valor que compara igual a cero. (por lo tanto ! E es lo mismo que ( 0 == E ) )

Ejecutar este código 
#include <stdbool.h>
#include <stdio.h>
#include <ctype.h>
int main(void)
{
    bool b = !(2+2 == 4); // no verdadero
    printf("!(2+2==4) = %s\n", b ? "true" : "false");
    int n = isspace('a'); // distinto de cero si 'a' es un espacio, cero en caso contrario
    int x = !!n; // "bang-bang", expresión idiomática común en C para mapear enteros a [0,1]
                 // (todos los valores distintos de cero se convierten en 1)
    char *a[2] = {"non-space", "space"};
    puts(a[x]); // ahora x puede usarse de forma segura como índice para un array de 2 strings
}

Salida: 

!(2+2==4) = false
non-space

AND lógico

La expresión lógica AND tiene la forma

lhs && rhs

donde

lhs - una expresión de cualquier tipo escalar
rhs - una expresión de cualquier tipo escalar, que solo se evalúa si lhs no es igual a ​ 0 ​

El operador lógico-AND tiene tipo int y el valor 1 si tanto lhs como rhs se comparan diferentes de cero. Tiene el valor ​ 0 ​ en caso contrario (si lhs o rhs o ambos se comparan iguales a cero).

Hay un punto de secuencia después de la evaluación de lhs . Si el resultado de lhs se compara igual a cero, entonces rhs no se evalúa en absoluto (la llamada evaluación de cortocircuito )

Ejecutar este código 
#include <stdbool.h>
#include <stdio.h>
int main(void)
{
    bool b = 2+2==4 && 2*2==4; // b == true
    1 > 2 && puts("this won't print");
    char *p = "abc";
    if(p && *p) // common C idiom: if p is not null
                // AND if p does not point at the end of the string
    {           // (note that thanks to short-circuit evaluation, this
                //  will not attempt to dereference a null pointer)
    // ...      // ... then do some string processing
    }
}

OR Lógico

La expresión OR lógica tiene la forma

lhs || rhs

donde

lhs - una expresión de cualquier tipo escalar
rhs - una expresión de cualquier tipo escalar, que solo se evalúa si lhs se compara igual a ​ 0 ​

El operador lógico-OR tiene tipo int y el valor 1 si cualquiera de los dos lhs o rhs se compara como desigual a cero. Tiene valor ​ 0 ​ en caso contrario (si ambos lhs y rhs se comparan como iguales a cero).

Hay un punto de secuencia después de la evaluación de lhs . Si el resultado de lhs se compara desigual a cero, entonces rhs no se evalúa en absoluto (lo que se denomina evaluación de cortocircuito )

Ejecutar este código 
#include <stdbool.h>
#include <stdio.h>
#include <string.h>
#include <errno.h>
int main(void)
{
    bool b = 2+2 == 4 || 2+2 == 5; // true
    printf("true or false = %s\n", b ? "true" : "false");
    // logical OR can be used simialar to perl's "or die", as long as rhs has scalar type
    fopen("test.txt", "r") || printf("could not open test.txt: %s\n", strerror(errno));
}

Salida posible: 

true or false = true
could not open test.txt: No such file or directory

Referencias

  • Estándar C11 (ISO/IEC 9899:2011):
  • 6.5.3.3 Operadores aritméticos unarios (p: 89)
  • 6.5.13 Operador AND lógico (p: 99)
  • 6.5.14 Operador OR lógico (p: 99)
  • Estándar C99 (ISO/IEC 9899:1999):
  • 6.5.3.3 Operadores aritméticos unarios (p: 79)
  • 6.5.13 Operador AND lógico (p: 89)
  • 6.5.14 Operador OR lógico (p: 89)
  • Estándar C89/C90 (ISO/IEC 9899:1990):
  • 3.3.3.3 Operadores aritméticos unarios
  • 3.3.13 Operador AND lógico
  • 3.3.14 Operador OR lógico

Véase también

Precedencia de operadores

Operadores comunes
asignación incremento
decremento 		aritméticos lógicos comparación acceso a
miembros 		otros

a = b
a + = b
a - = b
a * = b
a / = b
a % = b
a & = b
a | = b
a ^ = b
a <<= b
a >>= b

++ a
-- a
a ++
a --

+ a
- a
a + b
a - b
a * b
a / b
a % b
~a
a & b
a | b
a ^ b
a << b
a >> b

! a
a && b
a || b

a == b
a ! = b
a < b
a > b
a <= b
a >= b

a [ b ]
* a
& a
a - > b
a. b

a ( ... )
a, b
( type ) a
a ? b : c
sizeof

_Alignof
(desde C11)
(hasta C23)

alignof
(desde C23)

Véase también

Documentación de C++ para Operadores lógicos