views:

943

answers:

2

Compile and run this code in C

#include <stdio.h>

int main()
{
  int a[] = {10, 20, 30, 40, 50};
  int index = 2;
  int i;

  a[index++] = index = index + 2;
  for(i = 0; i <= 4; i++)
    printf("%d\n", a[i]);
}

Output : 10 20 4 40 50

Now for the same logic in Java

class Check
{

  public static void main(String[] ar)
  {
    int a[] = {10, 20, 30, 40, 50};
    int index = 2;

    a[index++] = index = index + 2;
    for(int i = 0; i <= 4; i++)
      System.out.println(a[i]);
  }
}

Output : 10 20 5 40 50

Why is there output difference in both languages, output is understandable for Java but I cannot understand output in C

One more thing, if we apply the prefix ++ operator, we get the same result in both languages, why?

+62  A: 

That is because a[index++] = index = index + 2; invokes Undefined Behavior in C. Have a look at this

From the link:

..the second sentence says: if an object is written to within a full expression, any and all accesses to it within the same expression must be directly involved in the computation of the value to be written. This rule effectively constrains legal expressions to those in which the accesses demonstrably precede the modification. For example, the old standby i = i + 1 is allowed, because the access of i is used to determine i's final value. The example

 a[i] = i++

is disallowed because one of the accesses of i (the one in a[i]) has nothing to do with the value which ends up being stored in i (which happens over in i++), and so there's no good way to define--either for our understanding or the compiler's--whether the access should take place before or after the incremented value is stored. Since there's no good way to define it, the Standard declares that it is undefined, and that portable programs simply must not use such constructs. Similar to a[i++]=i (which invokes UB) your expression too invokes UB.

Your expression also has a similar behavior.

The behavior is well defined in Java.

Prasoon Saurav
would `a[index++] = index+2` (same result, mostly) be undefined, though. I'd have to look up the standard to be sure, to be honest.
Michiel Buddingh'
+1 .......... :)
missingfaktor
@Michiel: Yes that would be UB too, same reason.
Prasoon Saurav
+1 - Very good answer. Can you add a snippet about what is defined in Java? Just for the curious :-)
Topher Fangio
@Topher: paragjain's program in Java has well defined behavior.
Prasoon Saurav
`a[index++] = index+2` would also be undefined behavior. Think of it this way: the Standard says that the increment happens sometime before the end of the statement, and specifies no ordering other than that. Therefore, there is no way to know if the increment happens before or after the addition. (It's the same with `++index` - while the subscript value is the original `index + 1` it's undefined as to when the value is actually stored into `index`.) The Committee chose to call this undefined rather than unspecified in the Standard, meaning any behavior is legal.
David Thornley
@Topher: C and Java have very different goals here. C was designed to allow the compiler great freedom to improve performance, as befits a system implementation language. Java was designed to nail down all the possible behavior, to make it easier on the programmer. Both C and Java have been very successful.
David Thornley
A: 

@Prasoon : Nice answer !

Chankey Pathak
indiv
Sorry, I will take care of this from next time.Thanks.
Chankey Pathak
@Chankey: Sorry I didn't see your post. Thanks BTW :)
Prasoon Saurav
You're welcome :)
Chankey Pathak