C Programming - Expressions - Discussion

The priority wise we decide only which belongs to which operator.. but the operation for short circuit operands (||,&&)are always left to right.

See, here the question is;

m=++i||b++&&++k
step 1: the compiler will decide which is belongs to which operand according to the priority.
So, the above statement will become like.

m= ++i || (b++ && ++k);
step 2: even after assigning like this operation is always from left to right.
so ++i is -2 i,e TRUE .
so,
m=TRUE|| (++j&&++k);
now it won't check the rest.
because it is short-circuited operator. if 1st argument is TRUE it won't check 2nd argument. because;
for ||
TRUE || TRUE=TRUE
TRUE || FALSE=TRUE
FALSE || TRUE = TRUE
FALSE || FALSE= FALSE
So it will check the second argument only if 1st argument is false.
But for our problem 1st arg is true.. so it won't check the rest.

Note: You may have another question like why j and k values are not incremented.
if we do like that then we are violating the short circuit operator rule.

&& and || operator guarantees left to right EVALUATION.

For example : E1 && E2 (E1 and E2 are subexpressions) then always E1 will evaluate before E2. Now if E1=0 no need to evaluate E2 as a result of the expression will be zero if E1=0 and if E1 is not equal to 0 then E2 will be evaluated.

In this question m = ++i || ++j && ++k; even if we increment j and k first we are actually violating left to right evaluation rule for || operator as m= E1 || E2, where E1= ++i, E2= ++j && ++k;

According to rule E1 should evaluate before E2 so we can't increment j and K and also we can't evaluate && after increment.

Therefore ++i operates first and since i=logical 1 no need to evaluate E2 (which is ++j && ++k).

A correctly formed expression that may produce an unexpected result.

Means here m = ++i || ++j && ++k;

Then Formed Expression is m = ++i || (++j && ++k); This is called Grouping the expression.

Then It starts evaluating from left to right also. When evaluating the expression in assignment operation ++i becomes non-zero. So it takes it as true and not evaluates the rest of the expression.

Take the reverse case also that is m= (++j && ++k) || ++i;

Then ++i is not get evaluated as based upon left to right evaluation.

So the conclusion is that there is preference for left to right evaluation as well after grouping the expression.

First there is a fight whether ++j belongs to || or &&.According to priority && wins so the compiler groups as ++i || (++j && ++k) ==> the left and right values are the operands of || .OR always evaluates from left to right.

As left gets evaluated and found to be true right is not evaluated due to short circuit evaluation hence the output is;

-2,2,0,1.

Precedence of logical operators,

1. ! Logical NOT.

2. && Logical AND.

3. || Logical OR.

No matter of associativity since the expression contain operators of different precedence.

I don't why it doesn't evaluate && expression since && has higher precedence than ||. I was wondering if someone could explain about this.

Our misconceptions are, negative(-) numbers including zero are False. Truth is,
Non-Zero numbers are 'True' in C.
eg: -3,-2,-1...1,2,3 ----> True
0 -----> False (only).

In other languages, the rule is negative(-) numbers including zero(0) is False, otherwise True.

@Anu Even Though according to the precedence rule the pre increment should be done first then its logical AND and at the end its logical OR this doesn't happen because of compiler optimisation. How to know about compiler optimization in solving problems. Like this.

Precedence of logical operators,

1. ! Logical NOT

2. && Logical AND

3. || Logical OR

And associativity of Logical operators Left to Right.

So that,

m = ++i || ++j && ++k;

That's why (++j && ++k;) this code will not get executed.

In this question for OR operator if anyone condition is true output is true so according to this we don't want to evaluate other operators so time for doing this operation is saved and speed if this process increases. This is compiler optimisation.

int i=-1, j=-1, k=1, m;
m = ++k && ++j || ++i;
printf("%d, %d, %d, %d\n", i, j, k, m);

In this case, the whole expression is evaluating the result is 0, 0, 2, 0 bit in the example problem it is evaluating only left.