C++ Operator Precedence
Die folgende Tabelle listet die Präzedenz und Assoziativität der C++-Operatoren auf. Operatoren sind von oben nach unten in absteigender Präzedenz aufgelistet. a , b und c sind Operanden.
| Priorität | Operator | Beschreibung | Assoziativität |
|---|---|---|---|
| 1 | a :: b | Gültigkeitsbereichsauflösung | Links-nach-rechts → |
| 2 | a ++ a -- | Suffix/Postfix Inkrement und Dekrement | |
type
(
a
)
type
{
a
}
|
Funktionscast | ||
| a ( ) | Funktionsaufruf | ||
| a [ ] | Indexoperator | ||
| a. b a - > b | Elementzugriff | ||
| 3 | ++ a -- a | Präfix Inkrement und Dekrement | Rechts-nach-links ← |
| + a - a | Unäre Plus- und Minusoperatoren | ||
| ! a ~a | Logisches NICHT und Bitweises NICHT | ||
(
type
)
a
|
C-Style-Cast | ||
| * a | Indirektion (Dereferenzierung) | ||
| & a | Adressoperator | ||
sizeof
|
Größenoperator [Anmerkung 1] | ||
| co_await | Await-Ausdruck (C++20) | ||
new
–
new[]
|
Dynamische Speicherallokation | ||
delete
–
delete[]
|
Dynamische Speicherfreigabe | ||
| 4 | a. * b a - > * b | Zeiger-auf-Member | 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 Linksverschiebung und Rechtsverschiebung | |
| 8 | a <=> b | Drei-Wege-Vergleichsoperator (seit C++20) | |
| 9 | a < b a <= b a > b a >= b |
Für
Vergleichsoperatoren
<
und
<=
und
>
und
>=
jeweils
|
|
| 10 | a == b a ! = b |
Für
Vergleichsoperatoren
=
und
!=
entsprechend
|
|
| 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 | Bedingter ternärer Operator [Anmerkung 2] | Rechts-nach-links ← |
throw
|
throw-Operator | ||
| co_yield | Ausdrucksanweisung (C++20) | ||
| a = b | Direkte Zuweisung (standardmäßig für C++-Klassen bereitgestellt) | ||
| a + = b a - = b | Zusammengesetzte Zuweisung durch Addition und Subtraktion | ||
| a * = b a / = b a % = b | Zusammengesetzte Zuweisung durch Produkt, Quotient und Rest | ||
| a <<= b a >>= b | Zusammengesetzte Zuweisung durch bitweise Linksverschiebung und Rechtsverschiebung | ||
| 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 kann kein C-Stil Typ-Cast sein: Der Ausdruck sizeof ( int ) * p wird eindeutig interpretiert als ( sizeof ( int ) ) * p , aber nicht als sizeof ( ( int ) * p ) .
-
↑
Der Ausdruck in der Mitte des bedingten Operators (zwischen
?und:) wird geparst, als wäre er in Klammern gesetzt: Seine Präzedenz relativ zu?:wird ignoriert.
Beim Parsen eines Ausdrucks wird ein Operator, der in einer Zeile der obigen Tabelle mit einer höheren Priorität aufgeführt ist, enger (als ob durch Klammern) an seine Argumente gebunden als jeder Operator, der in einer darunterliegenden Zeile mit einer niedrigeren Priorität aufgeführt ist. Zum Beispiel werden die Ausdrücke std:: cout << a & b und * p ++ geparst als ( std:: cout << a ) & b und * ( p ++ ) , und nicht als std:: cout << ( a & b ) oder ( * p ) ++ .
Operatoren mit derselben Priorität werden entsprechend ihrer Assoziativität an ihre Argumente gebunden. Beispielsweise wird der Ausdruck a = b = c als a = ( b = c ) geparst und nicht als ( a = b ) = c aufgrund der Rechts-nach-links-Assoziativität der Zuweisung, aber a + b - c wird als ( a + b ) - c geparst und nicht als a + ( b - c ) aufgrund der Links-nach-rechts-Assoziativität von Addition und Subtraktion.
Die Assoziativitätsangabe ist für unäre Operatoren redundant und wird nur der Vollständigkeit halber gezeigt: unäre Präfixoperatoren assoziieren immer rechts-nach-links ( delete ++* p ist delete ( ++ ( * p ) ) ) und unäre Postfixoperatoren assoziieren immer links-nach-rechts ( a [ 1 ] [ 2 ] ++ ist ( ( a [ 1 ] ) [ 2 ] ) ++ ). Beachten Sie, dass die Assoziativität für Member-Zugriffsoperatoren bedeutsam ist, obwohl sie mit unären Postfixoperatoren gruppiert werden: a. b ++ wird als ( a. b ) ++ geparst und nicht als a. ( b ++ ) .
Die Operator-Präzedenz wird durch Operator-Überladung nicht beeinflusst. Zum Beispiel wird std:: cout << a ? b : c ; als ( std:: cout << a ) ? b : c ; geparst, da die Präzedenz des arithmetischen Linksshifts höher ist als die des bedingten Operators.
Hinweise
Präzedenz und Assoziativität sind Kompilierzeit-Konzepte und unabhängig von der Auswertungsreihenfolge , welche ein Laufzeit-Konzept ist.
Der Standard selbst legt keine Vorrangstufen fest. Sie werden aus der Grammatik abgeleitet.
const_cast
,
static_cast
,
dynamic_cast
,
reinterpret_cast
,
typeid
,
sizeof...
,
noexcept
und
alignof
sind nicht enthalten, da sie niemals mehrdeutig sind.
Einige der Operatoren haben alternative Schreibweisen (z.B. and für && , or für || , not für ! , usw.).
In C hat der ternäre bedingte Operator eine höhere Priorität als Zuweisungsoperatoren. Daher wird der Ausdruck e = a < d ? a ++ : a = d , der in C++ als e = ( ( a < d ) ? ( a ++ ) : ( a = d ) ) geparst wird, in C aufgrund grammatikalischer oder semantischer Einschränkungen nicht kompilieren. Weitere Einzelheiten finden Sie auf der entsprechenden C-Seite.
Siehe auch
| Häufige Operatoren | ||||||
|---|---|---|---|---|---|---|
| Zuweisung |
Inkrement
Dekrement |
Arithmetik | Logisch | Vergleich |
Member
Zugriff |
Sonstige |
|
a
=
b
|
++
a
|
+
a
|
!
a
|
a
==
b
|
a
[
...
]
|
Funktionsaufruf
a ( ... ) |
|
Komma
a, b |
||||||
|
Bedingungsoperator
a ? b : c |
||||||
| Spezielle Operatoren | ||||||
|
static_cast
konvertiert einen Typ in einen anderen verwandten Typ
|
||||||
|
C-Dokumentation
für
C-Operator-Präzedenz
|