vary simple c code:
#include <stdio.h>
int main() {
int arr[] = {1, 2, 3, 4, 5};
int *ptr = arr;
printf("%d, %d\n", *ptr, *(++ptr));
return 0;
}
compiled with gcc 4.8.2, result:
2, 2
compiled with clang 3.4, result:
1, 2
why does this happen?
The comma used when calling a function does not come with a sequence point.
Therefore, this code *ptr, *(++ptr) invokes undefined behavior, because it attempts to access ptr twice between sequence points, for other purposes than to determine what value to assign to ptr.
This is defined by C11 6.5/2, in the following gibberish text:
If a side effect on a scalar object is unsequenced relative to either a different side effect on the same scalar object or a value computation using the value of the same scalar object, the behavior is undefined. If there are multiple allowable orderings of the subexpressions of an expression, the behavior is undefined if such an unsequenced side effect occurs in any of the orderings.
In our case, the side effect (changing ptr with ++ in *(++ptr)) is unsequenced in relation to the value computation of the same object (*ptr).
And since it is undefined behavior, anything can happen. Since your program does "something", it behaves as expected (or rather, as "unexpected").
In addition, the order of evaluation of function parameters is unspecified, so you cannot know whether the first or second parameter in the function call gets evaluated first. The order can differ not only between compilers, but between source code lines in the same program. The compiler can evaluate them in any order it likes and it does not need to document how.
Try this:
#include <stdio.h>
int main() {
int arr[] = {1, 2, 3, 4, 5};
int *ptr = arr;
printf("%d, %d\n", ptr[0], ptr[1]);
/* Or this
printf("%d, %d\n", ptr[1], ptr[0]);
whichever you meant
*/
return 0;
}
There is order defined for the order of evaluation of function arguments, the compilers can choose whatever they like. I can do *(++ptr) first, followed by *ptr , which would result in argmuents 2, 2 being passed to printf, or the other way around, which results in 1, 2 being passed to printf.
The evaluation order in the printf line is unspecified, which alone is enough to allow both interpretations.
In addition, there are no sequence points between the two pointer accesses. This causes undefined behaviour (read: Your program might crash, work as you expect, or upload your harddrive contents to the internet, depending on the current day of week, and what compiler you're using).
If you compile with warnings, you'll notice the following:
mic@mic-nb $ gcc test.c -std=c11 -Wall -Wextra -pedantic
test.c: In function ‘main’:
test.c:6:29: warning: operation on ‘ptr’ may be undefined [-Wsequence-point]
printf("%d, %d\n", *ptr, *(++ptr));
^
mic@mic-nb $ clang test.c -std=c11 -Wall -Wextra -pedantic
test.c:6:29: warning: unsequenced modification and access to 'ptr' [-Wunsequenced]
printf("%d, %d\n", *ptr, *(++ptr));
~~~ ^
1 warning generated.
Life tip: Always compile with -Wall -Wextra -pedantic, always fix all warnings, always test with both clang and gcc, and you'll have a whole lot less errors. I even add -Werror to my release build configs.
