Undefined Behavior of Postfix or Prefix Increment in Function Calls in C [duplicate]

Answer 1

There are two things your example code requires us to consider:

1. The function arguments order of evaluation is unspecified. Therefore, either ++a or a++ is evaluated first but it is implementation-dependent.

2. Modifying the value of a more than once without a sequence point in between the modifications is also undefined behavior.

Because of point 2, you have double undefined behavior here (you do it twice). Note undefined behavior doesn't mean nothing happens; it means anything can happen.

call(a,a++,++a); /* UB 1 */
printf("****%d %d %d***_\n",a,a++,++a); /* UB 2 */

Answer 2

That is undefined behaviour and as such it is entirely up to the implementation of the compiler in which order the following operations are done:

1. submit argument a
2. submit argument a++
3. submit argument ++a
4. increment a for ++a
5. increment a for a++

The only thing that the compiler knows is: 2. has to happen before 5. and 4. has to happen before 3.

You are observing:

++a;
submit argument 2
a++;
submit the other arguments

Answer 3

There's no requirement that a be equal to anything; that's what is meant by undefined behavior. It's entirely up to the compiler to evaluate the arguments to call and to printf in any order it sees fit, because the language does not specify what order they need to be evaluated.

Answer 4

The C and C++ standards do not indicate an order of evaluation for function arguments. To be blunt, it is not incorrect for a compiler to cause the parameters to be evaluated from right to left, or left to right.

The best answer is, Stay Away from this type of 'Undefined Behavior'; as it can lead to subtle portability problems.