Namespaces
Variants
Actions

Logical operators

From cppreference.com
< c‎ | language
 
 
 
 

Logical operators apply standard boolean algebra operations to their operands.

Operator Operator name Example Result
! logical NOT !a the logical negation of a
&& logical AND a && b the logical AND of a and b
|| logical OR a || b the logical OR of a and b

[edit] Logical NOT

The logical NOT expression has the form

! expression

where

expression - an expression of any scalar type

The logical NOT operator has type int. Its value is 0 if expression evaluates to a value that compares unequal to zero. Its value is 1 if expression evaluates to a value that compares equal to zero. (so !E is the same as (0==E))

Run this code
#include <stdbool.h>
#include <stdio.h>
#include <ctype.h>
int main(void)
{
 bool b = !(2+2 == 4); // not true
 printf ("!(2+2==4) = %s\n", b ? "true" : "false");
 
 int n = isspace ('a'); // non-zero if 'a' is a space, zero otherwise
 int x = !!n; // "bang-bang", common C idiom for mapping integers to [0,1]
 // (all non-zero values become 1)
 char *a[2] = {"non-space", "space"};
 puts (a[x]); // now x can be safely used as an index to array of 2 strings
}

Output:

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

[edit] Logical AND

The logical AND expression has the form

lhs && rhs

where

lhs - an expression of any scalar type
rhs - an expression of any scalar type, which is only evaluated if lhs does not compare equal to 0

The logical-AND operator has type int and the value 1 if both lhs and rhs compare unequal to zero. It has the value 0 otherwise (if either lhs or rhs or both compare equal to zero).

There is a sequence point after the evaluation of lhs. If the result of lhs compares equal to zero, then rhs is not evaluated at all (so-called short-circuit evaluation)

Run this code
#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
 }
}

[edit] Logical OR

The logical OR expression has the form

lhs || rhs

where

lhs - an expression of any scalar type
rhs - an expression of any scalar type, which is only evaluated if lhs compares equal to 0

The logical-OR operator has type int and the value 1 if either lhs or rhs compare unequal to zero. It has value 0 otherwise (if both lhs and rhs compare equal to zero).

There is a sequence point after the evaluation of lhs. If the result of lhs compares unequal to zero, then rhs is not evaluated at all (so-called short-circuit evaluation)

Run this code
#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));
}

Possible output:

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

[edit] References

  • C11 standard (ISO/IEC 9899:2011):
  • 6.5.3.3 Unary arithmetic operators (p: 89)
  • 6.5.13 Logical AND operator (p: 99)
  • 6.5.14 Logical OR operator (p: 99)
  • C99 standard (ISO/IEC 9899:1999):
  • 6.5.3.3 Unary arithmetic operators (p: 79)
  • 6.5.13 Logical AND operator (p: 89)
  • 6.5.14 Logical OR operator (p: 89)
  • C89/C90 standard (ISO/IEC 9899:1990):
  • 3.3.3.3 Unary arithmetic operators
  • 3.3.13 Logical AND operator
  • 3.3.14 Logical OR operator

[edit] See Also

Operator precedence

Common operators
assignment increment
decrement
arithmetic logical comparison member
access
other

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
(since C11)
(until C23)

alignof
(since C23)

[edit] See also

C++ documentation for Logical operators
Retrieved from "https://en.cppreference.com/mwiki/index.php?title=c/language/operator_logical&oldid=171168"

AltStyle によって変換されたページ (->オリジナル) /