Порядок вычисления

Порядок вычисления любой части любого выражения, включая порядок вычисления аргументов функции, является неопределённым (за некоторыми исключениями, перечисленными ниже). Компилятор может вычислять операнды и другие подвыражения в любом порядке и может выбрать другой порядок при повторном вычислении того же выражения.

В C++ нет понятия вычисления слева направо или справа налево. Не следует путать это с левоассоциативностью и правоассоциативностью операторов: выражение a() + b() + c() разбирается как (a() + b()) + c() из-за левоассоциативности operator+, но c() может вычисляться первым, последним или между a() и 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

Правила «упорядочено перед» (начиная с C++11)

Вычисление выражений

Вычисление каждого выражения включает:

• Вычисление значения: вычисление значения, возвращаемого выражением. Оно может включать определение идентичности объекта (вычисление glvalue, например, если выражение возвращает ссылку на объект) или чтение значения, ранее присвоенного объекту (вычисление prvalue, например, если выражение возвращает число или какое-либо другое значение).
• Инициирование побочных эффектов: обращение (чтение или запись) к объекту, обозначенному volatile glvalue, изменение (запись) объекта, вызов библиотечной функции ввода-вывода или вызов функции, выполняющей любую из этих операций.

Упорядочение

Упорядочено перед — это асимметричное транзитивное попарное отношение между вычислениями A и B в одном потоке.

• Если A упорядочено перед B (или, что эквивалентно, B упорядочено после A), то вычисление A завершится до начала вычисления B.
• Если A не упорядочено перед B, а B упорядочено перед A, то вычисление B завершится до начала вычисления A.
• Если A не упорядочено перед B и B не упорядочено перед A, возможны два варианта:
  • Вычисления A и B не упорядочены : они могут выполняться в любом порядке и могут перекрываться (в одном потоке выполнения компилятор может чередовать инструкции ЦП, составляющие A и B).
  • Вычисления A и B упорядочены неопределённо : они могут выполняться в любом порядке, но не могут перекрываться: либо A завершится до B, либо B завершится до A. При следующем вычислении того же выражения порядок может быть обратным.

Если не указано иное, вычисления операндов отдельных операторов и подвыражений отдельных выражений не упорядочены.

Правила

• каждое выражение аргумента и постфиксное выражение, обозначающее func

• каждое выражение или оператор в теле функции func

Неопределённое поведение

Поведение является неопределённым в следующих случаях:

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

Правила точек следования (до C++11)

Определения до C++11

Вычисление выражения может приводить к побочным эффектам: обращению к объекту, обозначенному volatile lvalue, изменению объекта, вызову библиотечной функции ввода-вывода или вызову функции, выполняющей любую из этих операций.

Точка следования — это точка в последовательности выполнения, в которой все побочные эффекты предыдущих вычислений в последовательности завершены, а побочные эффекты последующих вычислений ещё не начались.

Правила до C++11

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

Неопределённое поведение до C++11

Поведение является неопределённым в следующих случаях:

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

Отчёты об ошибках стандарта

Следующие отчёты об ошибках, изменяющие поведение, были ретроактивно применены к ранее опубликованным стандартам C++.

Ссылки

• Стандарт C++23 (ISO/IEC 14882:2024):
• 6.9.1 Выполнение программы [intro.execution]
• 7.6.1.6 Инкремент и декремент [expr.post.incr]
• 7.6.2.8 New [expr.new]
• 7.6.14 Оператор логического И [expr.log.and]
• 7.6.15 Оператор логического ИЛИ [expr.log.or]
• 7.6.16 Условный оператор [expr.cond]
• 7.6.19 Операторы присваивания и составного присваивания [expr.ass]
• 7.6.20 Оператор запятая [expr.comma]
• 9.4.5 Инициализация списком [dcl.init.list]
• Стандарт C++20 (ISO/IEC 14882:2020):
• 6.9.1 Выполнение программы [intro.execution]
• 7.6.1.5 Инкремент и декремент [expr.post.incr]
• 7.6.2.7 New [expr.new]
• 7.6.14 Оператор логического И [expr.log.and]
• 7.6.15 Оператор логического ИЛИ [expr.log.or]
• 7.6.16 Условный оператор [expr.cond]
• 7.6.19 Операторы присваивания и составного присваивания [expr.ass]
• 7.6.20 Оператор запятая [expr.comma]
• 9.4.4 Инициализация списком [dcl.init.list]
• Стандарт C++17 (ISO/IEC 14882:2017):
• 4.6 Выполнение программы [intro.execution]
• 8.2.6 Инкремент и декремент [expr.post.incr]
• 8.3.4 New [expr.new]
• 8.14 Оператор логического И [expr.log.and]
• 8.15 Оператор логического ИЛИ [expr.log.or]
• 8.16 Условный оператор [expr.cond]
• 8.18 Операторы присваивания и составного присваивания [expr.ass]
• 8.19 Оператор запятая [expr.comma]
• 11.6.4 Инициализация списком [dcl.init.list]
• Стандарт C++14 (ISO/IEC 14882:2014):
• 1.9 Выполнение программы [intro.execution]
• 5.2.6 Инкремент и декремент [expr.post.incr]
• 5.3.4 New [expr.new]
• 5.14 Оператор логического И [expr.log.and]
• 5.15 Оператор логического ИЛИ [expr.log.or]
• 5.16 Условный оператор [expr.cond]
• 5.17 Операторы присваивания и составного присваивания [expr.ass]
• 5.18 Оператор запятая [expr.comma]
• 8.5.4 Инициализация списком [dcl.init.list]
• Стандарт C++11 (ISO/IEC 14882:2011):
• 1.9 Выполнение программы [intro.execution]
• 5.2.6 Инкремент и декремент [expr.post.incr]
• 5.3.4 New [expr.new]
• 5.14 Оператор логического И [expr.log.and]
• 5.15 Оператор логического ИЛИ [expr.log.or]
• 5.16 Условный оператор [expr.cond]
• 5.17 Операторы присваивания и составного присваивания [expr.ass]
• 5.18 Оператор запятая [expr.comma]
• 8.5.4 Инициализация списком [dcl.init.list]

См. также

• Приоритет операторов, определяющий, как выражения формируются из их исходного кода.