CareerCup

15

12

j will be 12. The compiler will scan from left to right. at first it will get ++i then increment i by one and store the value of i = 2+1 = 3 for addition. then it will move to the next ++i and also increment i to 4 and store it. And so...

so j = 3+4+5 = 12

It's undefined behavior - see Sequence_point at wikipedia

its is undefined in c no sequence point is there in mid so no fix evaluation order

Crappy coding practice. Not worth consideration.

13 coming please explain!!!!

Its 12 as Raquibur said it above.

Since its ++i, its preincrement operator which makes i = 3 at first.
So when it goes to compute second ++i, i is already = 3 and preincrement will make it 4.
Next time the value is 5.

So (++i) + (++i) + (++i) = 3 + 4 + 5 = 12.

13 is the output when executed on g++ compiler.

The explanation for 13 is as follows, the first (++i) evaluates it to 3. But there is no temporary variable created for the expression evaluation. Now the next after the next (++i) is evaluated then the value of i becomes 4. Now because there was no temp variable created, the expression evaluates to (++i)+(++i) = 4 + 4. But after this there is a temp variable with value 8 created and is not effected by further increments of i. Therefore, (++i)+(++i)+(++i) = 4 + 4 + 5 = 13

I dont think the behavior will be undefined here. Pre-increments are always calculated before calculating an expression so before 'j' is calculated, 'i' will be incremented 3 times which gives i = 5 and j = 5 + 5 + 5 = 15.

The result turns out to be 13 (when run, might be implementation dependent).
The explanation is like this.

++i will increment the value to 3. But its reference will be used
++i will increment the value to 4. Again the reference will be used. Since there is no paranthesis, the compiler will first sum the first two, and evaluate the third one.

4+4+5 = 13

if you had paranthesis

like

j=(++i)+((++i)+(++i)) the result wil lbe 15 for similar resons.

it is compiler dependent.gcc returns 13 whereas turbo c returns 15 as the answer

Turbo see first pre-increments i and then use the incremented value in place of i and evaluates the expression i.e,-5+5+5=15.
gcc compiler first increments only 2 instances of pre-increment and uses it.the next pre incremented operand is incremented and added and so on.i,e,=>4+4+5=13
example=>(++i)+(++i)+(++i)+(++i)+(++i),i=2.the expression is evaluated as=>4+4+5+6+7=26.

yup that work for me.
turbo c returns the correct(or the expected result)
while gcc(i use dev c compiler) works on different principal,as explained above.parentheses has nothing do here

yup..it will b 15.

j=12 is the output.however the 'i' which is incremented first may be the compiler dependent.since it is all sum of numbers there is no issue,however if it is a subtraction the answer may be compiler dependent