C++ Operator Precedence
Le tableau suivant liste la précédence et l'associativité des opérateurs C++. Les opérateurs sont listés de haut en bas, par précédence décroissante. a , b et c sont des opérandes.
| Priorité | Opérateur | Description | Associativité |
|---|---|---|---|
| 1 | a :: b | Résolution de portée | Gauche à droite → |
| 2 | a ++ a -- | Incrémentation et décrémentation suffixe/postfixe | |
type
(
a
)
type
{
a
}
|
Cast fonctionnel | ||
| a ( ) | Appel de fonction | ||
| a [ ] | Indice | ||
| a. b a - > b | Accès aux membres | ||
| 3 | ++ a -- a | Incrémentation et décrémentation préfixées | Droite à gauche ← |
| + a - a | Plus et moins unaires | ||
| ! a ~a | NON logique et NON bit à bit | ||
(
type
)
a
|
Cast de style C | ||
| * a | Indirection (déréférencement) | ||
| & a | Adresse-de | ||
sizeof
|
Taille-de [note 1] | ||
| co_await | expression d'attente (C++20) | ||
new
–
new[]
|
Allocation dynamique de mémoire | ||
delete
–
delete[]
|
Désallocation dynamique de la mémoire | ||
| 4 | a. * b a - > * b | Pointeur-vers-membre | Gauche à droite → |
| 5 | a * b a / b a % b | Multiplication, division et reste | |
| 6 | a + b a - b | Addition et soustraction | |
| 7 | a << b a >> b | Opérateurs de décalage binaire vers la gauche et vers la droite | |
| 8 | a <=> b | Opérateur de comparaison à trois voies (depuis C++20) | |
| 9 | a < b a <= b a > b a >= b |
Pour les
opérateurs relationnels
<
et
<=
et
>
et
>=
respectivement
|
|
| 10 | a == b a ! = b |
Pour les
opérateurs d'égalité
=
et
!=
respectivement
|
|
| 11 | a & b | ET binaire | |
| 12 | a ^ b | OU exclusif binaire (ou exclusif) | |
| 13 | a | b | OU binaire (ou inclusif) | |
| 14 | a && b | ET logique | |
| 15 | a || b | OU logique | |
| 16 | a ? b : c | Conditionnel ternaire [note 2] | Droite à gauche ← |
throw
|
opérateur throw | ||
| co_yield | expression de rendement (C++20) | ||
| a = b | Affectation directe (fournie par défaut pour les classes C++) | ||
| a + = b a - = b | Affectation composée par somme et différence | ||
| a * = b a / = b a % = b | Affectation composée par produit, quotient et reste | ||
| a <<= b a >>= b | Affectation composée par décalage binaire vers la gauche et vers la droite | ||
| a & = b a ^ = b a | = b | Affectation composée par ET, XOR et OU bit à bit | ||
| 17 | a, b | Virgule | Gauche à droite → |
- ↑ L'opérande de sizeof ne peut pas être un cast de type style C : l'expression sizeof ( int ) * p est interprétée sans ambiguïté comme ( sizeof ( int ) ) * p , et non comme sizeof ( ( int ) * p ) .
-
↑
L'expression au milieu de l'opérateur conditionnel (entre
?et:) est analysée comme si elle était entre parenthèses : sa précédence par rapport à?:est ignorée.
Lors de l'analyse d'une expression, un opérateur listé dans une ligne du tableau ci-dessus avec une précédence sera lié plus étroitement (comme s'il était entre parenthèses) à ses arguments que tout opérateur listé sur une ligne inférieure avec une précédence plus faible. Par exemple, les expressions std:: cout << a & b et * p ++ sont analysées comme ( std:: cout << a ) & b et * ( p ++ ) , et non comme std:: cout << ( a & b ) ou ( * p ) ++ .
Les opérateurs ayant la même précédence sont liés à leurs arguments dans le sens de leur associativité. Par exemple, l'expression a = b = c est analysée comme a = ( b = c ) , et non comme ( a = b ) = c en raison de l'associativité droite-à-gauche de l'affectation, mais a + b - c est analysée ( a + b ) - c et non a + ( b - c ) en raison de l'associativité gauche-à-droite de l'addition et de la soustraction.
La spécification de l'associativité est redondante pour les opérateurs unaires et n'est montrée que par souci d'exhaustivité : les opérateurs unaires préfixés s'associent toujours de droite à gauche ( delete ++* p est delete ( ++ ( * p ) ) ) et les opérateurs unaires postfixés s'associent toujours de gauche à droite ( a [ 1 ] [ 2 ] ++ est ( ( a [ 1 ] ) [ 2 ] ) ++ ). Notez que l'associativité est significative pour les opérateurs d'accès aux membres, même s'ils sont regroupés avec les opérateurs unaires postfixés : a. b ++ est analysé comme ( a. b ) ++ et non comme a. ( b ++ ) .
La précédence des opérateurs n'est pas affectée par la surcharge d'opérateurs . Par exemple, std:: cout << a ? b : c ; est analysé comme ( std:: cout << a ) ? b : c ; car la précédence du décalage arithmétique vers la gauche est supérieure à celle de l'opérateur conditionnel.
Notes
La précédence et l'associativité sont des concepts de compilation et sont indépendants de l' ordre d'évaluation , qui est un concept d'exécution.
La norme elle-même ne spécifie pas les niveaux de précédence. Ils sont dérivés de la grammaire.
const_cast
,
static_cast
,
dynamic_cast
,
reinterpret_cast
,
typeid
,
sizeof...
,
noexcept
et
alignof
ne sont pas inclus car ils ne sont jamais ambigus.
Certains opérateurs possèdent des orthographes alternatives (par exemple, and pour && , or pour || , not pour ! , etc.).
En C, l'opérateur conditionnel ternaire a une priorité plus élevée que les opérateurs d'affectation. Par conséquent, l'expression e = a < d ? a ++ : a = d , qui est analysée en C++ comme e = ( ( a < d ) ? ( a ++ ) : ( a = d ) ) , ne compilera pas en C en raison de contraintes grammaticales ou sémantiques en C. Consultez la page C correspondante pour plus de détails.
Voir aussi
| Opérateurs courants | ||||||
|---|---|---|---|---|---|---|
| affectation |
incrémentation
décrémentation |
arithmétique | logique | comparaison |
accès
membre |
autres |
|
a
=
b
|
++
a
|
+
a
|
!
a
|
a
==
b
|
a
[
...
]
|
appel de fonction
a ( ... ) |
|
virgule
a, b |
||||||
|
conditionnel
a ? b : c |
||||||
| Opérateurs spéciaux | ||||||
|
static_cast
convertit un type en un autre type apparenté
|
||||||
|
Documentation C
pour
la précédence des opérateurs C
|