Order of evaluation

L'ordre d'évaluation de toute partie d'une expression, y compris l'ordre d'évaluation des arguments de fonction, est non spécifié (à l'exception de certains cas énumérés ci-dessous). Le compilateur peut évaluer les opérandes et autres sous-expressions dans n'importe quel ordre, et peut choisir un autre ordre lorsque la même expression est évaluée à nouveau.

Il n'existe pas de concept d'évaluation de gauche à droite ou de droite à gauche en C++. Ceci ne doit pas être confondu avec l'associativité gauche-droite et droite-gauche des opérateurs : l'expression a ( ) + b ( ) + c ( ) est analysée comme ( a ( ) + b ( ) ) + c ( ) en raison de l'associativité gauche-droite de operator + , mais c ( ) peut être évalué en premier, en dernier, ou entre a ( ) ou b ( ) à l'exécution :

#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());       // les 6 permutations de sortie sont autorisées
    return a() + b() + c(); // les 6 permutations de sortie sont autorisées
}

b
c
a
c
a 
b

Règles "séquencé avant" (depuis C++11)

Évaluation des Expressions

L'évaluation de chaque expression comprend :

• Calculs de valeur : calcul de la valeur retournée par l'expression. Cela peut impliquer la détermination de l'identité de l'objet (évaluation glvalue, par exemple si l'expression retourne une référence à un objet) ou la lecture de la valeur précédemment assignée à un objet (évaluation prvalue, par exemple si l'expression retourne un nombre ou une autre valeur).
• Initiation des effets secondaires : accès (lecture ou écriture) à un objet désigné par une glvalue volatile, modification (écriture) d'un objet, appel d'une fonction d'E/S de la bibliothèque, ou appel d'une fonction effectuant l'une de ces opérations.

Ordonnancement

Sequenced before est une relation asymétrique, transitive et binaire entre les évaluations A et B au sein du même thread.

• Si A est séquencé avant B (ou, de manière équivalente, B est séquencé après A ), alors l'évaluation de A sera terminée avant que l'évaluation de B ne commence.
• Si A n'est pas séquencé avant B et B est séquencé avant A , alors l'évaluation de B sera terminée avant que l'évaluation de A ne commence.
• Si A n'est pas séquencé avant B et B n'est pas séquencé avant A , alors deux possibilités existent :
  • Les évaluations de A et B sont non séquencées  : elles peuvent être effectuées dans n'importe quel ordre et peuvent se chevaucher (au sein d'un seul thread d'exécution, le compilateur peut entrelacer les instructions CPU qui composent A et B ).
  • Les évaluations de A et B sont séquencées de manière indéterminée  : elles peuvent être effectuées dans n'importe quel ordre mais ne peuvent pas se chevaucher : soit A sera terminé avant B , soit B sera terminé avant A . L'ordre peut être opposé la prochaine fois que la même expression est évaluée.

Une expression X est dite séquencée avant une expression Y si chaque calcul de valeur et chaque effet secondaire associé à X est séquencé avant chaque calcul de valeur et chaque effet secondaire associé à l'expression Y .

Règles

Comportement indéfini

Le comportement est indéfini dans les cas suivants :

i = ++i + 2;       // bien défini
i = i++ + 2;       // comportement indéfini jusqu'à C++17
f(i = -2, i = -2); // comportement indéfini jusqu'à C++17
f(++i, ++i);       // comportement indéfini jusqu'à C++17, non spécifié après C++17
i = ++i + i++;     // comportement indéfini

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

Règles des points de séquence (jusqu'à C++11)

Définitions pré-C++11

L'évaluation d'une expression peut produire des effets secondaires, qui sont : accéder à un objet désigné par une lvalue volatile, modifier un objet, appeler une fonction d'E/S de bibliothèque, ou appeler une fonction qui effectue l'une de ces opérations.

Un point de séquence est un point dans la séquence d'exécution où tous les effets secondaires des évaluations précédentes dans la séquence sont terminés, et aucun effet secondaire des évaluations suivantes n'a commencé.

Règles pré-C++11

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

Comportement indéfini avant C++11

Le comportement est indéfini dans les cas suivants :

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

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

Références

Voir aussi

• Priorité des opérateurs qui définit la manière dont les expressions sont construites à partir de leur représentation en code source.