C/C++ - evaluation of the arguments in a function call

Question

Possible Duplicate:
order of evaluation of function parameters

Is it safe to use the following construction in C/C++?

f(g(), h());

where g() is expected to be evaluated first, then h().

Do all compilers show the same behavior on all architectures?

This question is asked so often here, I can't decide which one to chose for a duplicate marker... — PlasmaHH, Feb 02 '12 at 16:37
Thx, but what about real-world compilers? What order do they use? — psihodelia, Feb 02 '12 at 16:40

score 8 · Accepted Answer · edited May 23 '17 at 12:34

NO! There is no guarantee what order these are carried out in. Only that both g() and h() are carried out before f(). See this: http://www.gotw.ca/gotw/056.htm I think there's an updated C++11 version of that, I'll have a look.

Edit: C++11 version http://herbsutter.com/gotw/_102/

Edit 2: If you really want to know what specific compilers do, try this: http://www.agner.org/optimize/calling_conventions.pdf Section 7 (page 16) may be relevant, though it's a bit over my head, but for instance __cdecl calling convention means arguments are passed from right to left (at least stored that way), whereas for __fastcall "The first two DWORD or smaller arguments are passed in ECX and EDX registers; all other arguments are passed right to left." (http://msdn.microsoft.com/en-us/library/6xa169sk%28v=vs.71%29.aspx)

So it does vary for different compilers.

Much later edit: It turns out that for constructors using the initializer list syntax (curly braces {}), order of evaluation is guaranteed (even if it is a call to a constructor that does not take a std::initializer_list. See this question.

score 1 · Answer 2 · answered Feb 02 '12 at 16:40

See 1.9 Program execution:

Certain other aspects and operations of the abstract machine are described in this International Standard as unspecified (for example, order of evaluation of arguments to a function). Where possible, this International Standard defines a set of allowable behaviors.

and 8.3.6 Default arguments, 9:

[...] Default arguments are evaluated each time the function is called. The order of evaluation of function arguments is unspecified. Consequently, parameters of a function shall not be used in a default argument, even if they are not evaluated. [...]

score 1 · Answer 3 · answered Feb 02 '12 at 16:43

1

No, it's not safe - if you need a guaranteed order of evaluation, e.g. because of side effects, then you will need to do something like this:

foo = g();
bar = h();
f(foo, bar);

answered Feb 02 '12 at 16:43

Paul R

208,748
37
389
560

score 0 · Answer 4 · answered Feb 02 '12 at 16:35

0

No, the order of evaluation of arguments with respect to each other is unspecified. The only guarantee that you have is that they will not be executed concurrently with each other.

answered Feb 02 '12 at 16:35

Mankarse

39,818
11
97
141

1

[Where does that guarantee come from?](http://stackoverflow.com/questions/13443532/could-a-c-implementation-in-theory-parallelise-the-evaluation-of-two-functio) – Lightness Races in Orbit Nov 18 '12 at 19:11

score 0 · Answer 5 · answered Feb 02 '12 at 16:36

0

No. The standard don't define the order of evaluation in that case, and each compiler may do whatever it wants. I think that most of them (and specially gcc) evaluate the rightest first.

answered Feb 02 '12 at 16:36

asaelr

5,438
1
16
22

Depending on optimization flags (and the target hardware). – James Kanze Feb 02 '12 at 17:56

C/C++ - evaluation of the arguments in a function call

5 Answers5

Linked

Related