Order of evaluation

Order of evaluation of any part of any expression, including order of evaluation of function arguments is unspecified

There is no concept of left-to-right or right-to-left evaluation in C++. This is not to be confused with left-to-right and right-to-left associativity of operators: the expression a( ) + b( ) + c( ) is parsed as (a( ) + b( ) ) + c( ) due to left-to-right associativity of operator+, but c() may be evaluated first, last, or between a() or b()

#include <cstdio>
 
int a() { return std::puts("a"); }
int b() { return std::puts("b"); }
int c() { return std::puts("c"); }
 
void z(int, int, int) {}
 
int main()
{
    z(a(), b(), c());       // all 6 permutations of output are allowed
    return a() + b() + c(); // all 6 permutations of output are allowed
}

b
c
a
c
a 
b

"Sequenced before" rules (since C++11)

Evaluation of Expressions

Evaluation of each expression includes:

• Value computations
• Initiation of side effects: access (read or write) to an object designated by a volatile glvalue, modification (writing) to an object, calling a library I/O function, or calling a function that does any of those operations.

Ordering

Sequenced before is an asymmetric, transitive, pair-wise relationship between evaluations within the same thread.

• If A is sequenced before B (or, equivalently, B is sequenced after A), then evaluation of A will be complete before evaluation of B begins.
• If A is not sequenced before B and B is sequenced before A, then evaluation of B will be complete before evaluation of A begins.
• If A is not sequenced before B and B is not sequenced before A, then two possibilities exist:
  • Evaluations of A and B are unsequenced: they may be performed in any order and may overlap (within a single thread of execution, the compiler may interleave the CPU instructions that comprise A and B).
  • Evaluations of A and B are indeterminately sequenced

Rules

Undefined behavior

The behavior is undefined in the following cases:

i = ++i + 2;       // well-defined
i = i++ + 2;       // undefined behavior until C++17
f(i = -2, i = -2); // undefined behavior until C++17
f(++i, ++i);       // undefined behavior until C++17, unspecified after C++17
i = ++i + i++;     // undefined behavior

cout << i << i++; // undefined behavior until C++17
a[i] = i++;       // undefined behavior until C++17
n = ++i + i;      // undefined behavior

union U { int x, y; } u;
(u.x = 1, 0) + (u.y = 2, 0); // undefined behavior

Sequence point rules (until C++11)

Pre-C++11 Definitions

Evaluation of an expression might produce side effects, which are: accessing an object designated by a volatile lvalue, modifying an object, calling a library I/O function, or calling a function that does any of those operations.

A sequence point is a point in the execution sequence where all side effects from the previous evaluations in the sequence are complete, and no side effects of the subsequent evaluations started.

Pre-C++11 Rules

a && b
a || b
a ? b : c
a , b

Pre-C++11 Undefined behavior

The behavior is undefined in the following cases:

i = ++i + i++;     // undefined behavior
i = i++ + 1;       // undefined behavior
i = ++i + 1;       // undefined behavior
++ ++i;            // undefined behavior
f(++i, ++i);       // undefined behavior
f(i = -1, i = -1); // undefined behavior

cout << i << i++; // undefined behavior
a[i] = i++;       // undefined behavior

Defect reports

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

References

See also

• Operator precedence which defines how expressions are built from their source code representation.