Précédence des opérateurs C++

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.

Précédence	Opérateur	Description	Associativité
1	`a::b`	Résolution de portée	De gauche à droite →
2	`a++` `a--`	Suffixe/postfixe incrémentation et décrémentation
	`type(a)` `type{a}`	Conversion fonctionnelle
	`a()`	Appel de fonction
	`a[]`	Indice
	`a.b` `a->b`	Accès aux membres
3	`++a` `--a`	Préfixe incrémentation et décrémentation	De droite à gauche ←
	`+a` `-a`	Unaire plus et moins
	`!a` `~a`	NON logique et NON binaire
	`(type)a`	Conversion à la C
	`*a`	Indirection (déréférencement)
	`&a`	Adresse de
	`^^a`	opérateur de réflexion (depuis C++26)
	`sizeof`	Taille de^[1]
	`co_await`	expression await (C++20)
	`new` – `new[]`	Allocation mémoire dynamique
	`delete` – `delete[]`	Désallocation mémoire dynamique
4	`a.b` `a->b`	Pointeur vers membre	De 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`	Décalage binaire gauche et 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 (XOR)
13	`a \| b`	OU inclusif binaire (OR)
14	`a && b`	ET logique
15	`a \|\| b`	OU logique
16	`a ? b : c`	Conditionnel ternaire^[2]	De droite à gauche ←
	`throw`	opérateur throw
	`co_yield`	expression yield (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 gauche et droite
	`a &= b` `a ^= b` `a \|= b`	Affectation composée par ET, XOR et OU binaires
17	`a, b`	Virgule	De gauche à droite →

↑ L'opérande de sizeof ne peut pas être un cast de style C : l'expression sizeof (int) * p est interprétée sans ambiguïté comme (sizeof(int)) * p, mais pas 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 relative à ?: est ignorée.

Lors de l'analyse d'une expression, un opérateur qui figure sur une ligne du tableau ci-dessus avec une certaine précédence se liera plus étroitement (comme avec des parenthèses) à ses arguments que tout opérateur situé 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 se lient à leurs arguments dans la direction 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é de 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é de gauche à droite de l'addition et de la soustraction.

La spécification d'associativité est redondante pour les opérateurs unaires et n'est montrée que pour être complète : les opérateurs unaires préfixes s'associent toujours de droite à gauche (delete ++*p est delete(++(*p))) et les opérateurs unaires postfixes 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 groupés avec les opérateurs unaires postfixes : a.b++ est analysé (a.b)++ et non 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; s'analyse comme (std::cout << a) ? b : c; car la précédence du décalage arithmétique 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 + = b a - = b a * = b a / = b a % = b a & = b a \| = b a ^ = b a <<= b a >>= b	++ a -- a a ++ a --	+ a - a a + b a - b a * b a / b a % b ~a a & b a \| b a ^ b a << b a >> b	! a a && b a \|\| b	a == b a ! = b a < b a > b a <= b a >= b a <=> b	a [ ... ] * a & a a - > b a. b a - > * b a. * b	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é `dynamic_cast` convertit au sein des hiérarchies d'héritage `const_cast` ajoute ou supprime les qualificateurs cv `reinterpret_cast` convertit un type en un type non apparenté C-style cast convertit un type en un autre par un mélange de static_cast , const_cast , et reinterpret_cast `new` crée des objets avec une durée de stockage dynamique `delete` détruit les objets précédemment créés par l'expression new et libère la zone mémoire obtenue `sizeof` interroge la taille d'un type `sizeof...` interroge la taille d'un pack (depuis C++11) `typeid` interroge les informations de type d'un type `noexcept` vérifie si une expression peut lever une exception (depuis C++11) `alignof` interroge les exigences d'alignement d'un type (depuis C++11)

Documentation C pour la précédence des opérateurs C

[1] L'opérande de sizeof ne peut pas être un cast de style C : l'expression sizeof (int) * p est interprétée sans ambiguïté comme (sizeof(int)) * p, mais pas comme sizeof((int)*p).

[2] 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 relative à ?: est ignorée.

[1]

[2]

Support du compilateur
Autonome et hébergé
Langage
Bibliothèque standard
En-têtes de la bibliothèque standard
Exigences nommées
Macros de test de fonctionnalités (C++20)
Bibliothèque de support du langage
Bibliothèque de concepts (C++20)
Bibliothèque de diagnostics
Bibliothèque de gestion de la mémoire
Bibliothèque de métaprogrammation (C++11)
Bibliothèque d'utilitaires généraux
Bibliothèque de conteneurs
Bibliothèque d'itérateurs
Bibliothèque de plages (C++20)
Bibliothèque d'algorithmes
Bibliothèque de chaînes
Bibliothèque de traitement de texte
Bibliothèque numérique
Bibliothèque de date et heure
Bibliothèque d'entrée/sortie
Bibliothèque de système de fichiers (C++17)
Bibliothèque de support de concurrence (C++11)
Bibliothèque de contrôle d'exécution (C++26)
Spécifications techniques
Index des symboles
Bibliothèques externes

fr.cppreference.net

Namespaces

Variants

Précédence des opérateurs C++

Notes

Voir aussi