Logical Operators
suggest changeLogical AND
Performs a logical boolean AND of the two operands, yielding 1 if both operands are non-zero. The result has type int.
0 && 0 /* Returns 0. */
0 && 1 /* Returns 0. */
2 && 0 /* Returns 0. */
2 && 3 /* Returns 1. */
Logical OR
Performs a logical boolean OR of the two operands, yielding 1 if either operand is non-zero. The result has type int.
0 || 0 /* Returns 0. */
0 || 1 /* Returns 1. */
2 || 0 /* Returns 1. */
2 || 3 /* Returns 1. */
Logical NOT
Performs a logical negation. The result has type int. The operator yields 0 if the operand is non-zero, and 1 if the operand is zero.
!1 /* Returns 0. */
!5 /* Returns 0. */
!0 /* Returns 1. */
Short-Circuit Evaluation
There are some crucial properties common to both && and ||:
- the left-hand operand (LHS) is fully evaluated before the right-hand operand (RHS) is evaluated at all,
- there is a sequence point between the evaluation of the left-hand operand and the right-hand operand,
- and, most importantly, the right-hand operand is not evaluated at all if the result of the left-hand operand determines the overall result.
This means that:
- if the LHS evaluates to ‘true’ (non-zero), the RHS of
||will not be evaluated (because the result of ‘true OR anything’ is ‘true’), - if the LHS evaluates to ‘false’ (zero), the RHS of
&&will not be evaluated (because the result of ‘false AND anything’ is ‘false’).
This is important as it permits you to write code such as:
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";
}
If a negative value is passed to the function, the value >= 0 term evaluates to false and the value < NUM_NAMES term is not evaluated.
Found a mistake? Have a question or improvement idea?
Let me know.
Table Of Contents