Order of evaluation

Die Reihenfolge der Auswertung jedes Teils eines Ausdrucks, einschließlich der Reihenfolge der Auswertung von Funktionsargumenten, ist unspezifiziert (mit einigen unten aufgeführten Ausnahmen). Der Compiler kann Operanden und andere Teilausdrücke in beliebiger Reihenfolge auswerten und kann eine andere Reihenfolge wählen, wenn derselbe Ausdruck erneut ausgewertet wird.

Es gibt kein Konzept von Links-nach-rechts oder Rechts-nach-links Auswertung in C++. Dies ist nicht zu verwechseln mit Links-nach-rechts und Rechts-nach-links Assoziativität von Operatoren: der Ausdruck a ( ) + b ( ) + c ( ) wird geparst als ( a ( ) + b ( ) ) + c ( ) aufgrund der Links-nach-rechts Assoziativität von operator + , aber c ( ) könnte zuerst, zuletzt oder zwischen a ( ) oder b ( ) zur Laufzeit ausgewertet werden:

#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());       // alle 6 Permutationen der Ausgabe sind erlaubt
    return a() + b() + c(); // alle 6 Permutationen der Ausgabe sind erlaubt
}

b
c
a
c
a 
b

"Sequenced before"-Regeln (seit C++11)

Auswertung von Ausdrücken

Die Auswertung jedes Ausdrucks umfasst:

• Wertberechnungen : Berechnung des Werts, der durch den Ausdruck zurückgegeben wird. Dies kann die Bestimmung der Identität des Objekts (Glvalue-Auswertung, z.B. wenn der Ausdruck eine Referenz auf ein Objekt zurückgibt) oder das Lesen eines zuvor einem Objekt zugewiesenen Werts (Prvalue-Auswertung, z.B. wenn der Ausdruck eine Zahl oder einen anderen Wert zurückgibt) umfassen.
• Einleitung von Nebeneffekten : Zugriff (Lesen oder Schreiben) auf ein durch einen volatile-Glvalue bezeichnetes Objekt, Modifikation (Schreiben) eines Objekts, Aufruf einer Bibliotheks-E/A-Funktion oder Aufruf einer Funktion, die eine dieser Operationen durchführt.

Reihenfolge

Sequenced before ist eine asymmetrische, transitive, paarweise Beziehung zwischen Auswertungen A und B innerhalb desselben Threads.

• Wenn A vor B sequenziert ist (oder äquivalent, B nach A sequenziert ist), dann wird die Auswertung von A abgeschlossen sein, bevor die Auswertung von B beginnt.
• Wenn A nicht vor B sequenziert ist und B vor A sequenziert ist, dann wird die Auswertung von B abgeschlossen sein, bevor die Auswertung von A beginnt.
• Wenn A nicht vor B sequenziert ist und B nicht vor A sequenziert ist, dann existieren zwei Möglichkeiten:
  • Die Auswertungen von A und B sind nicht sequenziert  : sie können in beliebiger Reihenfolge ausgeführt werden und können sich überlappen (innerhalb eines einzelnen Ausführungsthreads kann der Compiler die CPU-Befehle, die A und B umfassen, verschachteln).
  • Die Auswertungen von A und B sind indeterminiert sequenziert  : sie können in beliebiger Reihenfolge ausgeführt werden, dürfen sich aber nicht überlappen: entweder wird A vor B abgeschlossen, oder B wird vor A abgeschlossen. Die Reihenfolge kann beim nächsten Auswerten des gleichen Ausdrucks umgekehrt sein.

Ein Ausdruck X wird als vorangestellt zu einem Ausdruck Y bezeichnet, wenn jede Wertberechnung und jeder Nebeneffekt von X vor jeder Wertberechnung und jedem Nebeneffekt des Ausdrucks Y ausgeführt wird.

Regeln

Undefiniertes Verhalten

Das Verhalten ist undefined in den folgenden Fällen:

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

Sequenzpunkt-Regeln (bis C++11)

Pre-C++11 Definitionen

Die Auswertung eines Ausdrucks kann Nebeneffekte erzeugen, welche sind: Zugriff auf ein Objekt, das durch einen volatile L-Wert bezeichnet wird, Modifizieren eines Objekts, Aufrufen einer Bibliotheks-I/O-Funktion oder Aufrufen einer Funktion, die eine dieser Operationen durchführt.

Ein sequence point ist ein Punkt in der Ausführungssequenz, an dem alle Nebeneffekte der vorherigen Auswertungen in der Sequenz abgeschlossen sind und keine Nebeneffekte der nachfolgenden Auswertungen begonnen haben.

Pre-C++11 Regeln

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

Pre-C++11 Undefiniertes Verhalten

Das Verhalten ist undefined in den folgenden Fällen:

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

Fehlerberichte

Die folgenden verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

Referenzen

Siehe auch

• Operator-Präzedenz die definiert, wie Ausdrücke aus ihrer Quellcode-Darstellung aufgebaut werden.