Opérateurs et précédence

Le niveau de précédence (de 1 à 17) indique dans quel ordre (croissant) sont évalués les opérateurs.
L'associativité (L>R ou L<R) indique si les opérateurs successifs sont associés de gauche à droite ou de droite à gauche (respectivement).

Niveau 1

:: 	                    Espace global (unaire)                  ::nom
:: 	                    Espace de nommage (binaire) 	        nom_de_classe::nom_de_membre

Niveau 2 (L>R)

()                      Parentheses                              (exp)
()                      Appel de fonction                        nom_de_fonction(paramètres)
()                      Initialisation                           type nom(exp)
{}                      Initialisation uniforme (C++11)          type nom{exp}
type()                  Cast fonctionnel                         type(exp)
type{}                  Cast fonctionnel (C++11)                 type{exp}
[]                      Accès à un tableau                       pointeur[exp]
.                       Accès à un membre d'objet                objet.membre
->                      Accès à un membre de pointeur d'objet    pointeur_objet->membre
++                      Post-incrementation                      lvalue++
––                      Post-decrementation                      lvalue––
typeid                  Run-time type information                typeid(type) or typeid(exp)
const_cast              Cast away const                          const_cast<type>(exp)
dynamic_cast            Run-time type-checked cast               dynamic_cast<type>(exp)
reinterpret_cast        Cast inter type                          reinterpret_cast<type>(exp)
static_cast             Cast inter type à la compilation         static_cast<type>(exp) 

Niveau 3 (L<R)

+                       Plus uniaire                             +exp
-                       Moins unaire                             -exp
++                      Pre-increment                            ++lvalue
––                      Pre-decrement                            ––lvalue
!                       NON logique                              !exp
~                       NON binaire                              ~exp
(type)                  Cast "façon C"                           (new_type)exp
sizeof                  Taille en oct.                           sizeof(type) or sizeof(exp)
&                       Adresse de                               &lvalue
*                       Déréferencement                          *exp
new                     Alloc. de mémoire dyn.                   new type
new[]                   Alloc. de tableau dyn.                   new type[exp]
delete                  Libération de memoire                    delete pointer
delete[]                Libération de tableau                    delete[] pointer 

Niveau 4 (L>R)

->*                     Selecteur de membre de pointeur          object_pointer->*pointer_to_member
.*                      Selecteur de membre d'objet              object.*pointer_to_member 

Niveau 5 (L>R)

*                       Multiplication                           exp * exp
/                       Division                                 exp / exp
%                       Modulo                                   exp % exp  

Niveau 6 (L>R)

+                       Addition                                 exp + exp
-                       Soustraction                             exp - exp  

Niveau 7 (L>R)

<<                      Décalage de bits à gauche                exp << exp
>>                      Décalage de bits à droite                exp >> exp  

Niveau 8 (L>R)

<                       Inférieur                                exp < exp
<=                      Inférieur ou égal                        exp <= exp
>                       Supérieur                                exp > exp
>=                      Supérieur ou égal                        exp >= exp 

Niveau 9 (L>R)

==                      Egalité                                  exp == exp
!=                      Inégalité                                exp != exp 

Niveau 10 (L>R)

& 	                    ET binaire 	                             exp & exp 

Niveau 11 (L>R)

^ 	                    OU exclusif binaire 	                 exp ^ exp 

Niveau 12 (L>R)

| 	                    OU binaire 	                             exp | exp 

Niveau 13 (L>R)

&& 	                    ET logique 	                             exp && exp 

Niveau 14 (L>R)

|| 	                    OU logique 	                             exp || exp 

Niveau 15 (L<R)

?:                      Ternaire                                 exp ? exp : exp
=                       Assignement                              lvalue = exp
*=                      Multiplication et assignement            lvalue *= exp
/=                      Division et assignement                  lvalue /= exp
%=                      Modulo et assignement                    lvalue %= exp
+=                      Addition et assignement                  lvalue += exp
-=                      Soustraction et assignement              lvalue -= exp
<<=                     Décalage gauche et assignement           lvalue <<= exp
>>=                     Décalage droite et assignement           lvalue >>= exp
&=                      ET binaire et assignement                lvalue &= exp
|=                      OU binaire et assignement                lvalue |= exp
^=                      OU exclusif binaire et assignement       lvalue ^= exp 

Niveau 16 (L<R)

throw 	                Lancé d'expression 	                     throw exp 

Niveau 17 (L>R)

, 	                    Opérateur virgule 	                     exp, exp