Order of evaluation

El orden de evaluación de cualquier parte de cualquier expresión, incluyendo el orden de evaluación de los argumentos de función es no especificado (con algunas excepciones listadas abajo). El compilador puede evaluar operandos y otras subexpresiones en cualquier orden, y puede elegir otro orden cuando la misma expresión es evaluada nuevamente.

No existe el concepto de evaluación de izquierda a derecha o de derecha a izquierda en C++. Esto no debe confundirse con la asociatividad de izquierda a derecha y de derecha a izquierda de los operadores: la expresión a ( ) + b ( ) + c ( ) se analiza como ( a ( ) + b ( ) ) + c ( ) debido a la asociatividad de izquierda a derecha del operator + , pero c ( ) podría evaluarse primero, al último, o entre a ( ) o b ( ) en tiempo de ejecución:

#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());       // se permiten las 6 permutaciones de salida
    return a() + b() + c(); // se permiten las 6 permutaciones de salida
}

b
c
a
c
a 
b

Reglas de "secuenciado antes" (desde C++11)

Evaluación de Expresiones

La evaluación de cada expresión incluye:

• Cálculos de valor : cálculo del valor que devuelve la expresión. Esto puede implicar la determinación de la identidad del objeto (evaluación glvalue, p.ej. si la expresión devuelve una referencia a algún objeto) o la lectura del valor previamente asignado a un objeto (evaluación prvalue, p.ej. si la expresión devuelve un número u otro valor).
• Iniciación de efectos secundarios : acceso (lectura o escritura) a un objeto designado por un glvalue volátil, modificación (escritura) de un objeto, llamada a una función de E/S de biblioteca, o llamada a una función que realice cualquiera de estas operaciones.

Ordenación

Secuenciado antes es una relación asimétrica, transitiva y de pares entre evaluaciones A y B dentro del mismo hilo.

• Si A está secuenciado antes de B (o, equivalentemente, B está secuenciado después de A ), entonces la evaluación de A se completará antes de que comience la evaluación de B .
• Si A no está secuenciado antes de B y B está secuenciado antes de A , entonces la evaluación de B se completará antes de que comience la evaluación de A .
• Si A no está secuenciado antes de B y B no está secuenciado antes de A , entonces existen dos posibilidades:
  • Las evaluaciones de A y B están sin secuenciar  : pueden realizarse en cualquier orden y pueden superponerse (dentro de un único hilo de ejecución, el compilador puede entrelazar las instrucciones de CPU que componen A y B ).
  • Las evaluaciones de A y B están indeterminadamente secuenciadas  : pueden realizarse en cualquier orden pero no pueden superponerse: ya sea que A se complete antes de B , o B se complete antes de A . El orden puede ser opuesto la próxima vez que se evalúe la misma expresión.

Se dice que una expresión X está secuenciada antes que una expresión Y si cada cálculo de valor y cada efecto secundario asociado con X está secuenciado antes de cada cálculo de valor y cada efecto secundario asociado con la expresión Y .

Reglas

Comportamiento indefinido

El comportamiento es undefined en los siguientes casos:

i = ++i + 2;       // bien definido
i = i++ + 2;       // comportamiento indefinido hasta C++17
f(i = -2, i = -2); // comportamiento indefinido hasta C++17
f(++i, ++i);       // comportamiento indefinido hasta C++17, no especificado después de C++17
i = ++i + i++;     // comportamiento indefinido

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

Reglas de puntos de secuencia (hasta C++11)

Definiciones Previas a C++11

La evaluación de una expresión podría producir efectos secundarios, los cuales son: acceder a un objeto designado por un lvalue volatile, modificar un objeto, llamar a una función de E/S de la biblioteca, o llamar a una función que realice cualquiera de esas operaciones.

Un punto de secuencia es un punto en la secuencia de ejecución donde todos los efectos secundarios de las evaluaciones previas en la secuencia están completos, y ningún efecto secundario de las evaluaciones posteriores ha comenzado.

Reglas Pre-C++11

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

Comportamiento indefinido anterior a C++11

El comportamiento es indefinido en los siguientes casos:

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

Informes de defectos

Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares de C++ publicados anteriormente.

Referencias

Véase también

• Precedencia de operadores que define cómo se construyen las expresiones a partir de su representación en código fuente.