Parentheses and logical operators

Question

consider this code (C++) :

int x = -4 , y = 5 ;
bool result = x > 0 && y++ < 10 ;

the expression (x > 0) will be evaluated first , and because (x > 0 = false) and due to short-circuit evaluation , the other expression (y++ < 10) won't be evaluated and the value of y will remain 5 .

now consider the following code :

int x = -4 , y = 5 ;
bool result = (x > 0) && (y++ < 10) ;

it is expected that the expressions in parentheses will be evaluated first so that before the logical AND is performed , the expression (y++ < 10) would have been evaluated and the value of y has became 6 , but the reality is that the value of y remains 5 . which means that even with the parentheses the evaluation is short-circuited and the expression (y++ < 10) is ignored .

What is the explanation for this case ?!

"It is expected that the expressions in parentheses will be evaluated first" -- **wrong**. The parentheses don't make a difference, `x > 0` is always evaluated first in both cases. — Adam Rosenfield, Oct 10 '12 at 21:57
Parentheses can override precedence, but [order of evaluation is independent of precedence](http://stackoverflow.com/a/5475260/179910). Order of evaluation is determined by sequence points (C, C++98/03) or ordering constraints (C++11), not precedence or associativity. — Jerry Coffin, Oct 10 '12 at 21:58
The right side is never evaluated unless the && occurs. While you are correct that parens should be evaluated first in math, boolean logic is a bit different in that it goes left to right guaranteed. — Benjamin Danger Johnson, Oct 10 '12 at 21:59

score 10 · Answer 1 · answered Oct 10 '12 at 21:56

The explanation is in the question - short-circuiting.

In C++, evaluation of && (and || for that matter) is guaranteed to be left-to-right, and as soon as a false is encountered (respectively true for ||), evaluation is guaranteed to stop.

Similar for Java I guess.

The parenthesis are redundant and not relevant in this case - it has nothing to do with operator precedence. It simply has to do with how && works:

In fact, the two versions

x > 0 && y++ < 10
(x > 0) && (y++ < 10)

are equivalent, because ++ has the highest precedence, followed by <,>, and finally &&. Pedantically, you should have written it as:

(x > 0) && ((y++) < 10)

5.14 Logical AND operator [expr.log.and]

1 The && operator groups left-to-right. The operands are both implicitly converted to type bool (clause 4). The result is true if both operands are true and false otherwise. Unlike &, && guarantees left-to-right evaluation: the second operand is not evaluated if the first operand is false. (emphasis mine)

FYI Java has the non-short-circuited AND (`&`) and OR (`|`). — Steve Kuo, Oct 11 '12 at 00:24
@SteveKuo those are bitwise operators, and the C++ versions too are non-short-circuiting. — Luchian Grigore, Oct 12 '12 at 08:26

score 1 · Answer 2 · answered Oct 10 '12 at 21:57

When the left side determines the result, the right side is not evaluated.

In the first case, the right side is y++ < 10, and this is not evaluated. In the second case, the right side is (y++ < 10), and this is not evaluated.

There is no rule that expressions in parentheses are evaluated first. Parentheses only group operands.

score 0 · Answer 3 · answered Oct 10 '12 at 22:00

Even with parentheses short-circuiting must still take place. Consider if you have an expression involving pointers:

int* ptr = 0;
int bar = 5;
bool result = (ptr != 0) && (*ptr == bar || bar > 10);

You clearly can't safely evaluate the right-hand side of the && there, but the parentheses are required to make the precedence work as intended. The parentheses simply determine the order of operations that are actually performed not that they happen in a particular order.

Parentheses and logical operators

3 Answers3

5.14 Logical AND operator [expr.log.and]