Namespaces
Variants
Actions

Order of evaluation

From cppreference.com
< cpp‎ | language
 
C++
 
C++ language
General topics
Flow control
Conditional execution statements
if
Iteration statements (loops)
for
range-for (C++11)
Jump statements
Functions
Function declaration
Lambda function expression
inline specifier
Dynamic exception specifications (until C++17*)
noexcept specifier (C++11)
Exceptions
Namespaces
Types
Specifiers
const/volatile
decltype (C++11)
auto (C++11)
constexpr (C++11)
consteval (C++20)
constinit (C++20)
Storage duration specifiers
Initialization
Expressions
Value categories
Order of evaluation
Alternative representations
Literals
Boolean - Integer - Floating-point
Character - String - nullptr (C++11)
User-defined (C++11)
Utilities
Attributes (C++11)
Types
typedef declaration
Type alias declaration (C++11)
Casts
Memory allocation
Classes
Class-specific function properties
explicit (C++11)
static

Special member functions
Templates
Miscellaneous
 
Expressions
General
Literals
Operators
Conversions
 

Order of evaluation of any part of any expression, including order of evaluation of function arguments is unspecified (with some exceptions listed below). The compiler can evaluate operands and other subexpressions in any order, and may choose another order when the same expression is evaluated again.

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() at runtime:

Run this code
#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
}

Possible output: 

b
c
a
c
a 
b

Contents

[edit] "Sequenced before" rules (since C++11)

[edit] Evaluation of Expressions

Evaluation of each expression includes:

  • Value computations: calculation of the value that is returned by the expression. This may involve determination of the identity of the object (glvalue evaluation, e.g. if the expression returns a reference to some object) or reading the value previously assigned to an object (prvalue evaluation, e.g. if the expression returns a number, or some other value).
  • 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.

[edit] Ordering

Sequenced before is an asymmetric, transitive, pair-wise relationship between evaluations A and B 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 : they may be performed in any order but may not overlap: either A will be complete before B, or B will be complete before A. The order may be the opposite the next time the same expression is evaluated.

An expression X is said to be sequenced before an expression Y if every value computation and every side effect associated with X is sequenced before every value computation and every side effect associated with the expression Y.

[edit] Rules

1) Each full-expression is sequenced before the next full-expression.
2) The value computations (but not the side effects) of the operands to any operator are sequenced before the value computation of the result of the operator (but not its side effects).
3) When calling a function func (whether or not the function is inline, and whether or not explicit function call syntax is used), each item in the following list is sequenced before the next item:
  • every argument expression and the postfix expression designating func
(since C++26)
  • every expression or statement in the body of func
(since C++26)
4) The value computation of the built-in post-increment and post-decrement operators is sequenced before its side effect.
5) The side effect of the built-in pre-increment and pre-decrement operators is sequenced before its value computation (implicit rule due to definition as compound assignment).
6) The first (left) operand of the built-in logical AND operator &&, the built-in logical OR operator || and the built-in comma operator , is sequenced before the second (right) operand.
7) The first operand in the conditional operator ?: is sequenced before the second or third operand.
8) The side effect (modification of the left argument) of the built-in assignment operator and of all built-in compound assignment operators is sequenced after the value computation (but not the side effects) of both left and right arguments, and is sequenced before the value computation of the assignment expression (that is, before returning the reference to the modified object).
9) In list-initialization, every value computation and side effect of a given initializer clause is sequenced before every value computation and side effect associated with any initializer clause that follows it in the brace-enclosed comma-separated list of initializers.
10) A function call that is not sequenced before or sequenced after another expression evaluation outside of the function (possibly another function call) is indeterminately sequenced with respect to that evaluation (the program must behave as if the CPU instructions that constitute a function call were not interleaved with instructions constituting evaluations of other expressions, including other function calls, even if the function was inlined).
The rule 10 has one exception: function calls made by a standard library algorithm executing under std::execution::par_unseq execution policy are unsequenced and may be arbitrarily interleaved with each other. (since C++17)
11) The call to the allocation function (operator new) is indeterminately sequenced with respect to(until C++17)sequenced before(since C++17) the evaluation of the constructor arguments in a new expression.
12) When returning from a function, copy-initialization of the temporary that is the result of evaluating the function call is sequenced before the destruction of all temporaries at the end of the operand of the return statement, which, in turn, is sequenced before the destruction of local variables of the block enclosing the return statement.
13) In a function-call expression, the expression that names the function is sequenced before every argument expression and every default argument.
14) In a function call, value computations and side effects of the initialization of every parameter are indeterminately sequenced with respect to value computations and side effects of any other parameter.
15) Every overloaded operator obeys the sequencing rules of the built-in operator it overloads when called using operator notation.
16) In a subscript expression E1[E2], E1 is sequenced before E2.
17) In a pointer-to-member expression E1.*E2 or E1->*E2, E1 is sequenced before E2 (unless the dynamic type of E1 does not contain the member to which E2 refers).
18) In a shift operator expression E1 << E2 and E1 >> E2, E1 is sequenced before E2.
19) In every simple assignment expression E1 = E2 and every compound assignment expression E1 @= E2, E2 is sequenced before E1.
20) Every expression in a comma-separated list of expressions in a parenthesized initializer is evaluated as if for a function call (indeterminately-sequenced).
(since C++17)

[edit] Undefined behavior

The behavior is undefined in the following cases:

1) A side effect on a