C++ Operatorrangfolge
Die folgende Tabelle listet die Rangfolge und Assoziativität von C++-Operatoren auf. Operatoren sind von oben nach unten in absteigender Rangfolge aufgeführt. a, b und c sind Operanden.
| Rangfolge | Operator | Beschreibung | Assoziativität |
|---|---|---|---|
| 1 | a::b | Scope-Auflösung | Links nach rechts → |
| 2 | a++ a-- | Suffix/Postfix Inkrement und Dekrement | |
type(a) type{a} |
Funktionaler Cast | ||
| a() | Funktionsaufruf | ||
| a[] | Subskript | ||
| a.b a->b | Mitgliedszugriff | ||
| 3 | ++a --a | Präfix Inkrement und Dekrement | Rechts nach links ← |
| +a -a | Unäres Plus und Minus | ||
| !a ~a | Logisches NICHT und Bitweises NICHT | ||
(type)a
|
C-Stil-Cast | ||
| *a | Indirektion (Dereferenzierung) | ||
| &a | Adress-von | ||
sizeof
|
Größe von[Hinweis 1] | ||
| co_await | await-Ausdruck (C++20) | ||
new – new[] |
Dynamische Speicherallokation | ||
delete – delete[] |
Dynamische Speicherfreigabe | ||
| 4 | a.*b a->*b | Zeiger auf Mitglied | Links nach rechts → |
| 5 | a * b a / b a % b | Multiplikation, Division und Rest | |
| 6 | a + b a - b | Addition und Subtraktion | |
| 7 | a << b a >> b | Bitweise Links- und Rechtsshift | |
| 8 | a <=> b | Drei-Wege-Vergleichsoperator (seit C++20) | |
| 9 | a < b a <= b a > b a >= b | Für relationale Operatoren < und <= sowie > und >= | |
| 10 | a == b a != b | Für Gleichheitsoperatoren = und != | |
| 11 | a & b | Bitweises UND | |
| 12 | a ^ b | Bitweises XOR (exklusives ODER) | |
| 13 | a | b | Bitweises ODER (inklusives ODER) | |
| 14 | a && b | Logisches UND | |
| 15 | a || b | Logisches ODER | |
| 16 | a ? b : c | Ternärer Konditionaloperator[Hinweis 2] | Rechts nach links ← |
throw
|
throw-Operator | ||
| co_yield | yield-Ausdruck (C++20) | ||
| a = b | Direkte Zuweisung (standardmäßig für C++-Klassen bereitgestellt) | ||
| a += b a -= b | Zusammengesetzte Zuweisung durch Summe und Differenz | ||
| a *= b a /= b a %= b | Zusammengesetzte Zuweisung durch Produkt, Quotient und Rest | ||
| a <<= b a >>= b | Zusammengesetzte Zuweisung durch bitweisen Links- und Rechtsshift | ||
| a &= b a ^= b a |= b | Zusammengesetzte Zuweisung durch bitweises UND, XOR und ODER | ||
| 17 | a, b | Komma | Links nach rechts → |
- ↑ Der Operand von sizeof darf kein C-Stil-Typ-Cast sein: der Ausdruck sizeof (int) * p wird eindeutig interpretiert als (sizeof(int)) * p, aber nicht sizeof((int)*p).
- ↑ Der Ausdruck in der Mitte des Bedingungsoperators (zwischen
?und:) wird so analysiert, als wäre er geklammert: seine Rangfolge relativ zu?:wird ignoriert.
Beim Parsen eines Ausdrucks wird ein Operator, der in einer Zeile der obigen Tabelle mit einer bestimmten Rangfolge aufgeführt ist, enger (als wäre er geklammert) an seine Argumente gebunden als jeder Operator, der in einer Zeile weiter unten mit einer niedrigeren Rangfolge aufgeführt ist. Zum Beispiel werden die Ausdrücke std::cout << a & b und *p++ als (std::cout << a) & b und *(p++) analysiert, und nicht als std::cout << (a & b) oder (*p)++.
Operatoren, die die gleiche Rangfolge haben, werden gemäß ihrer Assoziativität an ihre Argumente gebunden. Zum Beispiel wird der Ausdruck a = b = c als a = (b = c) analysiert und nicht als (a = b) = c aufgrund der Rechts-nach-Links-Assoziativität von Zuweisungen, aber a + b - c wird als (a + b) - c analysiert und nicht als a + (b - c) aufgrund der Links-nach-Rechts-Assoziativität von Addition und Subtraktion.
Die Assoziativitätsspezifikation ist für unäre Operatoren überflüssig und wird nur zur Vollständigkeit angezeigt: unäre Präfixoperatoren assoziieren immer von rechts nach links (delete ++*p ist delete(++(*p))) und unäre Postfixoperatoren assoziieren immer von links nach rechts (a[1][2]++ ist ((a[1])[2])++). Beachten Sie, dass die Assoziativität für Mitgliedszugriffsoperatoren sinnvoll ist, auch wenn sie mit unären Postfixoperatoren gruppiert sind: a.b++ wird als (a.b)++ analysiert und nicht als a.(b++).
Die Operatorrangfolge wird von der Operatorüberladung nicht beeinflusst. Zum Beispiel wird der Ausdruck std::cout << a ? b : c; als (std::cout << a) ? b : c; analysiert, da die Rangfolge des bitweisen Links-Shifts höher ist als die des bedingten Operators.
[bearbeiten] Hinweise
Rangfolge und Assoziativität sind Konzepte der Kompilierzeit und unabhängig von der Auswertungsreihenfolge, die ein Laufzeitkonzept ist.
Der Standard selbst spezifiziert keine Rangfolgen. Sie werden aus der Grammatik abgeleitet.
const_cast, static_cast, dynamic_cast, reinterpret_cast, typeid, sizeof..., noexcept und alignof sind nicht enthalten, da sie nie mehrdeutig sind.
Einige Operatoren haben alternative Schreibweisen (z.B. and für &&, or für ||, not für ! usw.).
In C hat der ternäre Bedingungsoperator eine höhere Rangfolge als Zuweisungsoperatoren. Daher wird der Ausdruck e = a < d ? a++ : a = d, der in C++ als e = ((a < d) ? (a++) : (a = d)) analysiert wird, in C aufgrund grammatikalischer oder semantischer Einschränkungen in C nicht kompiliert. Einzelheiten finden Sie auf der entsprechenden C-Seite.
[bearbeiten] Siehe auch
| Häufige Operatoren | ||||||
|---|---|---|---|---|---|---|
| Zuweisung | Inkrement Dekrement |
Arithmetik | Logisch | Vergleich | Member Zugriff |
Sonstiges |
|
a = b |
++a |
+a |
!a |
a == b |
a[...] |
Funktionsaufruf a(...) |
| Komma a, b | ||||||
| Ternär a ? b : c | ||||||
| Spezielle Operatoren | ||||||
|
static_cast konvertiert einen Typ in einen anderen verwandten Typ | ||||||
| C-Dokumentation für C-Operatorrangfolge
|
