Precedence of && over ||

Question

As I know logical operator && has higher precedence than ||. On running the code:

#include <stdio.h>

int main()
{
    int i = 1, j =1, k = 1;

    printf("%d\n",++i || ++j && ++k);
    printf("%d %d %d",i,j,k);

    return 0;
}

is giving the output:

1
2 1 1

which is possible only when ++i || ++j && ++k is evaluated like this:

(++i) || (++j && ++k)

But, according to operator precedence rule it should be evaluated as:

(++i || ++j) && (++k)

and hence output should be:

1
2 1 2

What is going wrong with this?

NOTE: As per my understanding I think an operator of higher precedence evaluated as follows(if it is left associative):
1. Evaluate its left expression
2. Then evaluate its right expression(if needed)
Am I wrong?

I think this is a somewhat flawed question, if you need to be explicit about precedence, use parenthesis to denote what order of precedence you want. Don't leave it up to the language or compiler to decide for you. Makes your code more readable and portable too — Dan F, Jul 02 '13 at 18:12
`(++i || ++j) && (++k)` would indicate || has higher precedence, which is false. — , Jul 02 '13 at 18:13
You answered your own question : the expression is evaluated as `(++i) || (++j && ++k)` because `&&` has higher precedence. You must remind yourself of the `BODMAS` rule from school mathematics. — rktcool, Jul 02 '13 at 18:17
The answer to your final question "Am I wrong?" is Yes. precedence has to do with which operator binds more tightly and nothing to do with order of evaluation. — Chris Dodd, Jul 02 '13 at 18:35
@OliCharlesworth; It may seems that it is possible duplicate of your provided link but, here issue is different. See the answer given by Jonathan Leffler. — haccks, Jul 02 '13 at 18:53
@haccks: It's the exact same issue, I think. Precedence doesn't dictate evaluation order, especially in the context of short-circuit operators. — Oliver Charlesworth, Jul 02 '13 at 19:00

score 13 · Answer 1 · edited May 23 '17 at 10:30

13

The || operator short-circuits - if its first operand evaluates to true (nonzero), it doesn't evaluate its second operand.

This is also true for &&, it doesn't use its second operand if the first one is false. This is an optimization that's possible because any boolean value OR true is true, and similarly, any boolean value AND false is always false.

OK, so you're confusing precedence with evaluation order. Nothing is contradictional here at all:

++i || ++j && ++k

is grouped as

(++i) || (++j && ++k)

since && has higher precedence. But then the LHS of the OR operation is true, so the whole RHS with its AND operation is discarded, it isn't evaluated.

To your note in the edit: yes, you're wrong: operator precedence is still not the same as order of evaluation. It's just grouping.

edited May 23 '17 at 10:30

Community

1
1

answered Jul 02 '13 at 18:08

Please read my question again , I am not asking this. – haccks Jul 02 '13 at 18:09
I am talking about operator precedence.Read my first line . – haccks Jul 02 '13 at 18:10
@haccks I know. And you're confusing operator precedence with order of evaluation. – Jul 02 '13 at 18:12
Yah.....true. I am confused with it. – haccks Jul 02 '13 at 18:12
@haccks Because || short circuits it never does any of the operations to the right of it. Try it with i = -1 – dakillakan Jul 02 '13 at 18:15
Man! why first grouping is correct I don't understand yet! – haccks Jul 02 '13 at 18:23
@haccks cause the language defines it so? – Jul 02 '13 at 18:25
Read my note.I have edited the question. – haccks Jul 02 '13 at 18:30
@haccks You seem to be ignoring the fact that operator precedence has nothing to do with evaluation order... – Jul 02 '13 at 18:34
Ya, true. I was in big dilemma. – haccks Jul 02 '13 at 18:54

AnT stands with Russia · Answer 2 · 2013-07-02T18:29:00.780

Firstly, as you said it yourself, && has higher precedence, which means that operand grouping should be

 (++i) || (++j && ++k)

Why you are saying that "according to operator precedence" it should be (++i || ++j) && (++k) is not clear to me. That just contradicts what you said yourself.

Secondly, operator precedence has absolutely nothing to do with order of evaluation. Operator precedence dictates the grouping between operators and their operands (i.e. operator precedence says which operand belongs to which operator).

Meanwhile, order of evaluation is a completely different story. It either remains undefined or defined by completely different set of rules. In case of || and && operators the order of evaluation is indeed defined as left-to-right (with mandatory early completion whenever possible).

So, operator precedence rules tell you that the grouping should be

 (++i) || ((++j) && (++k))

Now, order-of-evaluation rules tell you that first we evaluate ++i, then (if necessary) we evaluate ++j, then (if necessary) we evaluate ++k, then we evaluate && and finally we evaluate ||.

score 10 · Accepted Answer · edited Jun 20 '20 at 09:12

You say:

which is possible only when ++i || ++j && ++k is evaluated like this:
(++i) || (++j && ++k)
But, according to operator precedence rule it should be evaluated as:
(++i || ++j) && (++k)

The first grouping is correct because the precedence of && is higher than the precedence of ||. Then the expression as a whole evaluates the LHS of the ||, with the side-effect of incrementing i, which evaluates to true. That means that the RHS of the || (the && expression) is not evaluated at all because it is not needed to determine the truth of the overall expression.

So, the compiler is correct; you misunderstood precedence in some way.

Why is the first grouping correct? According to first grouping || has higher precedence than &&. What is going wrong with me?

You don't understand precedence, it seems, or you don't understand the interaction of precedence with order of evaluation. The first grouping gives higher precedence to &&.

If you have a + b * c, where * has a higher precedence than +, then it is evaluated as a + (b * c), is it not? Change + to || and * to && and the expressions are isomorphic and the interpretation is similar.

The big difference between the arithmetic expression and the logical expression is that the operands of the logical expression have to be evaluated left-to-right but the operands of the arithmetic expression do not; the compiler could evaluate b * c before evaluating a (but must evaluate b * c before doing the addition). By contrast, in the logical expression (a || b && c), the compiler must evaluate a before evaluating b && c, and when a turns out to be true, it must not evaluate either b or c, let alone b && c.

Why first grouping is correct? According to first grouping `||` has higher precedence than `&&`.What is going wrong with me? — haccks, Jul 02 '13 at 18:21

score 3 · Answer 4 · answered Jul 02 '13 at 18:35

3

Since you are misunderstanding precedence, let's try to clear it up with a mathematical example. Multiplication and division have a higher precedence than addition and subtraction. Which means that this expression:

a + b * c - d / e

Can be written like this:

a + (b * c) - (d / e)

Since you correctly stated that && has higher precedence than ||, this expression:

i || j && k

can be written like this:

i || (j && k)

You can think of it as "the operation with the highest precedence gets parenthesized first", if that helps.

(But precedence is different from evaluation - if i is true, then (j && k) will never be evaluated.)

answered Jul 02 '13 at 18:35

default.kramer

5,943
2
32
50

Your explanation is good, it also helps but Jonathan has explained this first in his comment. +1 – haccks Jul 02 '13 at 18:50
what happen in this case `z = p * r % q`? – haccks Jul 02 '13 at 19:10
2

Multiply and Remainder have the same precedence, so left-to-right breaks the tie: `z = ((p * r) % q)` – default.kramer Jul 02 '13 at 20:19

Precedence of && over ||

4 Answers4

Linked

Related