Order of evaluation of arguments in function calling?

Question

I am studying about undefined behavior in C and I came to a statement that states that

there is no particular order of evaluation of function argume

Answer 1

Check the book you mentioned for any references to "Sequence points", because I think that's what you're trying to get at.
Basically, a sequence point is a point that, once you've arrived there, you are certain that all preceding expressions have been fully evaluated, and its side-effects are sure to be no more.

For example, the end of an initializer is a sequence point. This means that after:

bool foo = !(i++ > j);

You are sure that i will be equal to i's initial value +1, and that foo has been assigned true or false. Another example:

int bar = i++ > j ? i : j;

Is perfectly predictable. It reads as follows: if the current value of i is greater than j, and add one to i after this comparison (the question mark is a sequence point, so after the comparison, i is incremented), then assign i (NEW VALUE) to bar, else assign j. This is down to the fact that the question mark in the ternary operator is also a valid sequence point.

All sequence points listed in the C99 standard (Annex C) are:

The following are the sequence points described in 5.1.2.3:
— The call to a function, after the arguments have been evaluated (6.5.2.2).
— The end of the first operand of the following operators: logical AND && (6.5.13); logical OR || (6.5.14); conditional ? (6.5.15); comma , (6.5.17).
— The end of a full declarator: declarators (6.7.5);
— The end of a full expression: an initializer (6.7.8); the expression in an expression statement (6.8.3); the controlling expression of a selection statement (if or switch) (6.8.4); the controlling expression of a while or do statement (6.8.5); each of the expressions of a for statement (6.8.5.3); the expression in a return statement (6.8.6.4).
— Immediately before a library function returns (7.1.4).
— After the actions associated with each formatted input/output function conversion specifier (7.19.6, 7.24.2).
— Immediately before and immediately after each call to a comparison function, and also between any call to a comparison function and any movement of the objects passed as arguments to that call (7.20.5).

What this means, in essence is that any expression that is not a followed by a sequence point can invoke undefined behaviour, like, for example:

printf("%d, %d and %d\n", i++, i++, i--);

In this statement, the sequence point that applies is "The call to a function, after the arguments have been evaluated". After the arguments are evaluated. If we then look at the semantics, in the same standard under 6.5.2.2, point ten, we see:

10 The order of evaluation of the function designator, the actual arguments, and subexpressions within the actual arguments is unspecified, but there is a sequence point before the actual call.

That means for i = 1, the values that are passed to printf could be:

1, 2, 3//left to right

But equally valid would be:

1, 0, 1//evaluated i-- first
//or
1, 2, 1//evaluated i-- second

What you can be sure of is that the new value of i after this call will be 2.
But all of the values listed above are, theoretically, equally valid, and 100% standard compliant.

But the appendix on undefined behaviour explicitly lists this as being code that invokes undefined behaviour, too:

Between two sequence points, an object is modified more than once, or is modified and the prior value is read other than to determine the value to be stored (6.5).

In theory, your program could crash, instead of printinf 1, 2, and 3, the output "666, 666 and 666" would be possible, too