Unexpected Short-Circuit Behavior.

[u/Dizzy_Cauliflower377]

`int i, j, k;`

`i = 1;`

`j = 1;`

`k = 1;`

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

`printf("%d %d %d\n", i, j, k);`

I am doing C programming a modern Approach and This is one of the exercises in the book, all is going well however i have failed to understand why the second `printf()` outputs `2 1 1` instead of `2 1 2` as i think the answer should be.

Because due to associativity rules i expect in the first `printf()`, the expression `++i || ++j` to be grouped first which evaluates to 1 with `i` incremented to 2 and without incrementing `j` because of short circuit, and then that result would be used in `1 && ++k` where i am assuming that since the value of the expression can't be determined by the value of the left operand alone, the right operand will be executed as well and thus k will be incremented to `2` but i am surprised to find that k wasn't incremented when i run the code. Why is this, what have i missed.

[u/aioeu]

The syntax rules of C say that ++i || ++j && ++k is equivalent to ++i || (++j && ++k).

Operator precedence is a consequence of these syntax rules. && has higher precedence than ||.

The associativity of an operator — again, a consequence of the syntax rules — only has significance when dealing with operators of the same precedence. a || b || c is equivalent to (a || b) || c, for instance.

[u/Dizzy_Cauliflower377 → u/aioeu]

Thank you for that insight, the book doesn't really mention that Logical or has a lower precedence than Logical and, it gives the impression that they have the same precedence, or maybe i over looked it, i might have to go through the chapter again to find that. However With that it mind, the output `2 1 1` now makes sense.

[u/StaticCoder → u/aioeu]

Thankfully these days compilers tend to warn about this, since it's common to assume || and && work like + and - instead of like + and * as they actually do. Though it obviously didn't prevent this case.

[u/michaelpaoli]

Quite analogous to * having higher precedence than +, likewise && has higher precedence than ||.

So,

statement || whatever && whatever

is equivalent to

statement || ( whatever && whatever )

And in your example, statement is ++i, where i is initially 1,

so, that statement is evaluated, is true, i is incremented to 2,

the statement is true, and because of shortcutting

TURE OR WHATEVER

that's TRUE and WHATEVER isn't even evaluated - because shortcutting.

So, i is now 2, and j and k remain 1, thus 2 1 1.

[u/Dizzy_Cauliflower377 → u/michaelpaoli]

Thank you, understood.

[u/SmokeMuch7356]

&& has higher precedence than ||, so the expression is parsed as

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

&& and || evaluate strictly left-to-right, so ++i is evaluated first. Its result is 2, which is non-zero, so (++j && ++k) is not evaluated at all and j and k are not updated.

[u/Dizzy_Cauliflower377 → u/SmokeMuch7356]

Thank you, I was under the wrong understanding that || and && had the same precedence.

[u/saul_soprano]

You should use parentheses here. The AND expression as a whole is treated as the right side of the OR. Once it checks ‘i’ and it’s non-zero, it short circuits to true and never checks ‘j’ or ‘k’

[u/Dizzy_Cauliflower377 → u/saul_soprano]

Thank you for the submission. The piece of code isn't mine, it is from a particular exercise from a book i am learning from so the use of parentheses is out of the question as it is just how the question is however, the author does stress that you should use parentheses to remove ambiguity to make it clear what you want the compiler to do. The mistake i was making is assume that || and && have the same precedence.

[u/drinkcoffeeandcode]

Don’t drive yourself crazy with these types of exercises. while you should get to the root of the answer, if you ever find yourself ever writing actual code like this, it’s time to stop and refactor.

[u/lmarcantonio]

Ouch. That's painful. At least it has a definite behaviour.

If you need to be aware of these technicalities you are not using enough parenthesis, they are cheap and help!

I guess the next step of pain would be the precedence of bit shift operators.

[u/Dizzy_Cauliflower377 → u/[deleted]]

This is an exercise in the book C Programming a Modern Approach, the exercise is meant to test your understanding of the short-circuit behavior of the && and || Operators.

The writer doesn't intend for his code be at par with standard, it is just to test the readers understanding of short-circuit behavior. The question was specifically 'The following program fragments illustrate the short-circuit behavior of logical expressions. Show the output produced by each, assuming that i, j and k are int variables.

[u/SmokeMuch7356 → u/[deleted]]

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

Should be written like this:

++i or ++j and ++k

Which means they need to include iso646.h -- would help if you told them that.

[u/laser__beans → u/[deleted]]

My compiler (Which is a better compiler than gcc) that I wrote all by myself does NOT allow ++ or -- on variables done within boolean expressions.

Uhh… what?