Short Circuiting Logical OR Behavior - c

Question

I was under the impression that in the C language, the logical OR operator || is a short circuit operator that doesn't evaluate the rhs if the lhs is false. I've run into a problem when comparing OR'ed values. Can someone explain to me why the following code (on gcc 5.3) evaluates to true? I'm getting the same behavior in clang.
#include <stdio.h>
int main() {
int attr = 2;
if( ((attr & 2) != 2) || ((attr & 4) != 4) ) {
printf("No short circuit?\n");
};
printf("%i %i\n",attr,(attr & 2));
};
output:
No short circuit?
2 2

Answer 1

((attr & 2) != 2) || ((attr & 4) != 4) evaluates to true because
attr & 4 == 0 and (attr & 4) != 4 is 1 because attr & 4 is not equal to 4. (N1570 6.5.9 Equality operators)
Because at least one of the operand is not zero, the expression evaluates to 1. (N1570 6.5.14 Logical OR operator)
The if statement excutes the first substatement when the controlling expression is not zero (N1570 6.8.4.1 The if statement), and you will call it "the expression evaluated to true".
Logical OR operator won't evaluate rhs if the lhs is true because the value will be true in both case the rhs is true or false.
Logical AND operator won't evaluate rhs if the lhs is false because the value will be false in both case the rhs is true or false.
Quote from N1570:
6.5.13 Logical AND operator
[...]
3 The && operator shall yield 1 if both of its operands compare unequal to 0; otherwise, it
yields 0. The result has type int.
4 Unlike the bitwise binary & operator, the && operator guarantees left-to-right evaluation;
if the second operand is evaluated, there is a sequence point between the evaluations of
the first and second operands. If the first operand compares equal to 0, the second
operand is not evaluated.
6.5.14 Logical OR operator
[...]
3 The || operator shall yield 1 if either of its operands compare unequal to 0; otherwise, it
yields 0. The result has type int.
4 Unlike the bitwise | operator, the || operator guarantees left-to-right evaluation; if the
second operand is evaluated, there is a sequence point between the evaluations of the first
and second operands. If the first operand compares unequal to 0, the second operand is
not evaluated.

Answer 2

Code that you had:
((attr & 2) != 2) || ((attr & 4) != 4) )
What happens:
(attr & 2) evaluates to 2. (0010 AND 0010 = 0010 which is 2)
(2 != 2) evaluates to 0, or false.
Now the right side of the OR is evaluated (If the left side was true, then the right side would not be executed/evaluated, i.e. "Short circuit". But in this example it is false, so the right side is evaluated).
(attr & 4) is the bitwise and operation, e.g. 0010 & 0100. It evaluates to 0000, or 0.
(0 != 4) evaluates to 1, or true, so the body of the if statement executes.
The rest of the program (the last statement) then executes and the program terminates.
Remember:
& is bit-wise AND.
&& is Boolean AND.
| is bit-wise OR.
|| is Boolean OR.

Answer 3

Here's two ways you can get the short circuiting behavior in C:
unsigned int bitwise_logical_or(unsigned int p, unsigned int q) {
return (p | (q & ((p != 0) - 1)));
}
unsigned int numerical_logical_or(unsigned int p, unsigned int q) {
return p + (p == 0) * q;
}
As mentioned in other answers, the || operator returns true (0x01) or false (0x00).
bitwise_logical_or works as follows:
If bitwise or is performed on integers p and q, it will work only so long as p is zero. If p is not zero, bitwise or will intermingle p and q in an unpredictable way. If q could be set to zero if p is greater than zero we’ll get the result we want. Therefore, when p is non-zero, we’d like to perform a bitwise and between q and zero. The trick is that simply testing p == 0 will return (in 8 bit) 0x00 or 0x01. We need it to return 0xff or 0x00 appropriately. We accomplish this by checking p != 0, this will return 0x01 when p > 0 and 0x00 when p == 0. Subtract 1, and in the case that p > 0, you get 0x00 (false). When p == 0, you already have 0x00 (all zeros), there’s no where to go, so the integer wraps around (underflows) and you get 0xff (all ones).