Ambiguous operator priority, please explain why operator prediction is not respected here?

Question

x = y = z = 1; z = ++x||++y&&++z; 

Operator priority is as follows:

 (pre-increment) > && > || 

so the answer should be -

 1. 2||2 && 2 2. 2||1 3. 1 print x,y,z should be 2,2,1 

but the answer is 2.1.1.

Answer 1

Expressions with logical operators && and || evaluated from left to right:

C99, Section 6.5.14-4 Unlike the bitwise operator | operator || guarantees an assessment from left to right; after evaluating the first operand, there is a point in the sequence. If the first operand is not evenly compared to 0 , the second operand is not evaluated.

Since x++ not equal to zero, the short-circuit expression evaluates everything to the right of || including their side effects. Therefore, only x++ is evaluated, so x becomes 2 . The remaining variables remain at 1 , as they should.

Answer 2

Priority is not the same as the evaluation order. Priority simply determines which operands and operators belong to each other. The exact order of evaluation is unspecified except with logical operators, which are evaluated in strict order from left to right to enable a short circuit.

Since && has a higher priority, variables are first grouped as follows:

 (++x) || (++y && ++z) 

Then, following the order from left to right, ++x is evaluated. Given that ++x true, it is known that the whole expression is true. Thus, the expression evaluation is short-circuited. (++y && ++z) never evaluated. Therefore, y and z never increase.

Answer 3

There is no sequence point in the expression:

 z = ++x || ++y && ++z; 

between the pre-increment z and the assignment z .

So, if ++z is actually evaluated, it instantly puts you in the undefined behavior area, and anything can happen. You are not allowed to modify the same object twice without an intermediate point. Appendix C (from C99) lists all points in the sequence, and the control one follows the full expression (all calculation and assignment).

6.5 Expressions /2 :

Between the previous and next points in the sequence, the object must have the changed value of the stored value no more than once by evaluating the expression. In addition, the previous value should only be read to determine the stored value.

However, given that your initial x value is 1, part of the ++z expression is not evaluated in this particular case. This does not make the expression itself less dangerous, since it will call UB when the starting point is x == -1 and y != -1 .

In this case, the control part of the standard 6.5.14 Logical OR operator /4 :

Unlike bitwise | operator, || the operator guarantees evaluation from left to right; a sequence point appears after evaluating the first operand. If the first operand is compared to not equal to 0, the second operand is not evaluated.

So, ++x is evaluated first, and since it calculates a nonzero value, ++y && ++z never evaluated. x increases by 2 , and z set to the "true" value of this, or 1 , y remains untouched at 1 .