Explain why j is coming up with 150?

Question

#include <stdio.h>

main() {
  int i=3,j;  
  j=++i*++i*++i;
  printf("%d,%d",i,j);
}

The answer is upcoming up with i=6, j=150 Please explain why j is coming up with 150??

No return value, j not initialized.. what else can go wrong? — Loïc Faure-Lacroix, Feb 15 '14 at 15:53
for i=3,j=4*5*6=120.When i=6 this goes j=7*8*9=504. So, I have no idea why j == 150! — ThunderGr, Feb 15 '14 at 15:53
You should never write stuff like `j=++i*++i*++i;`. Even if you know about sequence points (and all its consequences), the reader of your code does not know that you know. — Bernd Elkemann, Feb 15 '14 at 15:54
@LoïcFaure-Lacroix no problem with `j` not being initialized at declaration, since it is in the following line, also, at last c++ doesn't require a return statement for `main`. — oblitum, Feb 15 '14 at 15:55
@pepper_chico I'm aware the problem has something to do with the `++` which could be cached or not.. UB. a void main wouldn't require a return. a `int main` should. — Loïc Faure-Lacroix, Feb 15 '14 at 15:56
its not related to j being uninitialized..its simply UB..http://ideone.com/yeOjq2 — Kamlesh Arya, Feb 15 '14 at 15:56
@LoïcFaure-Lacroix: no need to initialize, and no need for return value (at least, since C99. http://stackoverflow.com/questions/204476/what-should-main-return-in-c-and-c ). so yes, a lot of things can go wrong ;) — Karoly Horvath, Feb 15 '14 at 15:57
@LoïcFaure-Lacroix in c++ at last, it doesn't require. Not sure about the c standard, I think it's even more relaxed. — oblitum, Feb 15 '14 at 15:57
@KarolyHorvath what value will be returned by a `int main` by default then? 0? — Loïc Faure-Lacroix, Feb 15 '14 at 15:58
What was that editing in order to put the brace on the declaration? It makes the code less readable! — ThunderGr, Feb 15 '14 at 15:59
The code is perfectly correct!! But after complilation the answer is coming i=6, j=150. I don't know why it is giving 150 instead of 120. If i talk about the logic, since we know i++ mean firstly `i=i+1;` then `j=i;` by this, we get i=6 that's perfect right. But at j it should be `j=4*5*6` that will giving 120, but after complilation it is giving 150.! :( — Sudheesh, Feb 16 '14 at 04:38

score 9 · Answer 1 · edited May 23 '17 at 12:15

9

This Undefined behaviour is because of Sequence Points. See these links

Undefined behavior and sequence points

http://c-faq.com/expr/seqpoints.html

edited May 23 '17 at 12:15

Community

1
1

answered Feb 15 '14 at 16:02

Nishant Kumar

2,199
2
22
43

Theofilos Mouratidis · Answer 2 · 2014-02-16T08:39:19.350

2

This j=++i*++i*++i in your compiler will break into 1:(++i*++i)*++i then it will calculate the left operand and then the right one. The left one is a parenthesis so it will see what's inside. That ++i*++i will be evaluated as (++i)*(++i), then the compiler will calculate the left and right operands and then it will do the multiplication. The left operand will increase i by one and return i, right operand will increase i by one and will return i. So we got i*i in the first parenthesis of the 1 expression, i is 5 so it will return 25. Now we got (25)*(++i), compiler checks both operands, left one returns 25, right one increases i by one and returns i, i is now 6 so we got 25*6=150. This is how gcc works

edited Feb 16 '14 at 08:39

answered Feb 15 '14 at 16:10

Theofilos Mouratidis

1,146
12
32

This looks interesting. However when i=3, j=(++i)*(++i)*(++i) => j=(4)*(5)*(6) but, this is not accurate because i is now 6, so j=6*6*6 which is not 150. Why does it do 5*5, first, then * 6? – ThunderGr Feb 15 '14 at 16:15
Because when it does the first multiplication, it had to evaluate the "++" which affect the same register. Then the value is stored in an accumulator... when the last ++i is done it is multiplied with the accumulator. – Loïc Faure-Lacroix Feb 15 '14 at 16:18
Actually `j=(5)*(5)*(6)`. Parser first evaluates what is inside the parentheses then it makes the multiplication. – Theofilos Mouratidis Feb 15 '14 at 16:19
@ΘεόφιλοςΜουρατίδης but this is all good an fun but since the `++` is used, the result will mostly depend on the compilator. Using clang, it works as intended. – Loïc Faure-Lacroix Feb 15 '14 at 16:20
This means j=(6)*(6)*(6), as I said. *First* the parenthesis, then multiplication – ThunderGr Feb 15 '14 at 16:21
eval=i*i breaks the priorities of operators...So, It *is* UB. – ThunderGr Feb 15 '14 at 16:23
have you ever seen how compilers work? – Theofilos Mouratidis Feb 15 '14 at 16:24
Your order of execution simulates j=((++i)*(++i))*(++i); – ThunderGr Feb 15 '14 at 16:24
As it was pointed out clang calculates it correctly. If it is depended on the compiler, it is UB. – ThunderGr Feb 15 '14 at 16:25
@ThunderGr the UB is that you might be modifying the same register multiple times. there is no difference between `((++i)*(++i))*(++i)` and `(++i)*((++i)*(++i))`. – Loïc Faure-Lacroix Feb 15 '14 at 16:27
@LoïcFaure-Lacroix Of course there isn't a difference between the two but there is a difference between them and (++i)*(++i)*(++i) <> ((++i)*(++i)) * (++i) – ThunderGr Feb 15 '14 at 16:28
there is no correct answer at `++i*++i*++i`, he said why does it give 150 I answered him why it gives 150....Other compiler can do whatever it likes – Theofilos Mouratidis Feb 15 '14 at 16:28
You need to specify that it is UB and that his *specific compiler* does it this way because it calculates like that, IMO. – ThunderGr Feb 15 '14 at 16:29
Think about it, clang probably does that: `j = ++i; b= ++i; c=++i; j = j * b; j = j * c;` – Loïc Faure-Lacroix Feb 15 '14 at 16:29
In addition your claim that it calculates (++i)*(++i)*(++i) is wrong. It calculates ((++i)*(++i))*(++i) – ThunderGr Feb 15 '14 at 16:31
yeah sure. but for speed and memory eficiency compilers like gcc must make other decisions than clang does – Theofilos Mouratidis Feb 15 '14 at 16:32
http://stackoverflow.com/questions/21799800/explain-why-j-is-coming-up-with-150#comment32987375_21800069 this is the same thing. – Loïc Faure-Lacroix Feb 15 '14 at 16:33
@ThunderGr do you understand that a computer cannot calculate 3 values at the same time? it has to create a temporary register to compute `i*i*i` And the order there doesn't matter left to right or right to left. You get the same result. – Loïc Faure-Lacroix Feb 15 '14 at 16:34
we are in binary computers so 2 things will be done first, that's how registers work, Loic said the same thing – Theofilos Mouratidis Feb 15 '14 at 16:34
@LoïcFaure-Lacroix This is irrelevant, really. When it does ((++i)*(++i)) *(++i), you have ((5)*(5)) * (++i)=>25*(6)=150 – ThunderGr Feb 15 '14 at 16:36
You'd have `6*6*6` only if the compiler wanted to evaluate the `++` first. Which mean, you can have at least 3 possible results for the code posted above. 120, 150 and 216. – Loïc Faure-Lacroix Feb 15 '14 at 16:36
@ThunderGr the other way around you'd have `6 * 25` or something else... You could end up with `4 * 36` – Loïc Faure-Lacroix Feb 15 '14 at 16:38
please stop commenting guys, if you have an argument talk to chat, not here. I am being spammed right now... – Theofilos Mouratidis Feb 15 '14 at 16:40
if `j=++i*++i*++i;` in the same line by replacing `eval=++i*++i;` `++i;` `j=eval*++i;` What will be the answer and why?? – Sudheesh Feb 16 '14 at 04:58
as we know i++ means `i=i+1;` then assign `j=i;` by this logic it should be `j=4*5*6` but you are saying `j=5*5*6` It's contradiction! :( – Sudheesh Feb 16 '14 at 05:05
@Sudheesh It does calculations first in parentheses then it multiplies. – Theofilos Mouratidis Feb 16 '14 at 08:30

score 1 · Answer 3 · answered Feb 15 '14 at 16:20

The result is actually depend on the compiler.

I have compiled it with gcc and clang. Gcc outputs 150, and clang outputs 120.

But the disassemble can give the reason why j = 150:

movl   $0x3,-0xc(%rbp)  // i = 3
movl   $0x0,-0x10(%rbp) // j = 0
mov    -0xc(%rbp),%eax  // %eax = i = 3
add    $0x1,%eax        // %eax += 1, %eax = 4 
mov    %eax,-0xc(%rbp)  // move %eax back to i, ie i = 4
mov    -0xc(%rbp),%eax  // %eax = i = 4
add    $0x1,%eax        // %eax = 5
mov    %eax,-0xc(%rbp)  // move %eax back to i, ie i = 5
mov    -0xc(%rbp),%eax  // store i in %eax
mov    -0xc(%rbp),%ecx  // store i in %ecx
imul   %ecx,%eax        // %eax * %ecx, %eax = 5*5 = 25
mov    -0xc(%rbp),%ecx  // store i in %ecx
add    $0x1,%ecx        // %ecx + 1, %ecx = 6
mov    %ecx,-0xc(%rbp)  // move %ecx back to i, ie i = 6 
mov    -0xc(%rbp),%ecx  // store i in %ecx
imul   %ecx,%eax        // %eax * %ecx, %eax = 6*25=150
mov    %eax,-0x10(%rbp) // move %eax to j, ie j = 150

as I said in my answer with less details. – Theofilos Mouratidis Feb 15 '14 at 16:27 — Theofilos Mouratidis, Feb 15 '14 at 16:27

Explain why j is coming up with 150?

3 Answers3