Le langage C++ possède un grand nombre d'opérateurs de base effectuant entre autre des opérations arithmétiques et capables de travailler sur les entiers, les réels, etc... Nous allons présenter ici ces principaux opérateurs.
L'affectation.
Syntaxe.
 "identificateur"="expression"
Sémantique.
On commence par évaluer l'expression et on met le résultat dans la variable "identificateur".
Exemple.
using namespace std;
int main()
 int a, b, s;
 cout « "Tapez la valeur de a : "; cin » a;
 cout « "Tapez la valeur de b : "; cin » b;
 s = a + b; // affecter le résultat de l'addition à la variable s
 cout « "La somme a+b vaut : " « s « endl;
 return 0;
Exécution.
 Tapez la valeur de a : 45
 Tapez la valeur de b : 67
 La somme a+b vaut : 112
Explications.
Dans ce programme, on déclare 3 variables a, b et s. On demande à l'utilisateur du programme de taper la valeur de a puis la valeur de b. cout sert à l'affichage à l'écran et cin à la saisie au clavier. Le programme calcule ensuite dans la variable s la somme a+b. On affiche finalement la valeur de s.
Affectation à la déclaration.
L'affectation à la déclaration d'une variable est appelée "déclaration avec initialisation", car est un cas particulier de l'affectation (en particulier avec les objets).
Exemple :
int a = 57;
Affectation en série.
Le résultat d'une même expression peut être assigné à plusieurs variables sans la réévaluer, en une seule instruction :
 "identificateur2"="identificateur1"="expression"
Par exemple :
a = b = 38 + t;
En fait, l'affectation retourne une valeur : celle affectée à la variable. L'exemple précédent est donc équivalent à :
a = (b = 38 + t);
L'opération se déroule de la manière suivante :
Remarque importante.
Pour effectuer un test de comparaison, par exemple comparer a à 53, il ne faut pas écrire if(a=53) mais if(a==53) en utilisant 2 fois le symbole =. Une erreur classique !
Opérations arithmétiques.
sur les entiers.
On peut effectuer les opérations arithmétiques usuelles sur les entiers en utilisant les opérateurs +, -, / et *. Il faut juste avoir en tête que la division sur les entiers effectue une troncature (la partie décimale est perdue). Le modulo s'obtient en utilisant l'opérateur %. Ainsi a%b désigne le reste de la division de a par b. On peut utiliser les parenthèses pour fixer l'ordre d'évaluation des expressions. On peut aussi utiliser l'opérateur ++ pour incrémenter une variable de 1. L'opérateur --, quant à lui, décrémente une variable de 1.
sur les réels.
Sur les réels, on utilise les opérateurs +, -, * et / pour effectuer les 4 opérations de base. Il faut avoir en tête que toute opération sur les réels est entâchée d'une minuscule erreur de calcul : il s'agit d'un arrondi sur le dernier bit. Si on effectue de nombreux calculs, cette erreur peut s'amplifier et devenir extrêmement grande.
Les fonctions mathématiques habituelles sont présentes dans la bibliothèque standard <cmath>.
Exemple.
using namespace std;
int main()
 int a, b, M;
 cout « "Tapez la valeur de a : "; cin » a;
 cout « "Tapez la valeur de b : "; cin » b;
 M = (a+3) * (6+a) + (b-5) * 2;
 cout « "M vaut " « M « endl;
 return 0;
Exécution :.
 Tapez la valeur de a : 1
 Tapez la valeur de b : 2
 M vaut 22
Opérations binaires.
Les opérations présentées dans cette section opèrent au niveau des bits.
Les décalages.
Les décalages permettent de décaler vers la droite ou vers la gauche toute la représentation en binaire d'une valeur d'un certain nombre de bits.
Exemple.
using namespace std;
int main()
 int a = 5;
 int b;
 b = a « 3;
 cout«"b vaut : "«b«endl;
 b = (a+1) « 3;
 cout«"b vaut : "«b«endl;
 return 0;
Exécution.
 b vaut 40
 b vaut 48
Le ET binaire.
Syntaxe.
 "exp1 & exp2"
Sémantique.
Le résultat est obtenu en faisant un ET logique sur chaque bit de la représentation de exp1 avec le bit correspondant de la représentation de exp2.
Le ET logique a pour résultat 1 si les deux bits correspondants en entrée sont à 1 (pour 1-1), et sinon 0 (pour 0-1, 1-0 ou 0-0).
Exemple.
using namespace std;
int main()
 int a = 53;
 int b = 167;
 int c = a & b;
 cout « "c vaut " « c « endl;
 return 0;
Exécution.
 c vaut 37
Explications.
 53 s'écrit en binaire 0000 0000 0000 0000 0000 0000 0011 0101
 167 s'écrit en binaire 0000 0000 0000 0000 0000 0000 1010 0111
 ET binaire 0000 0000 0000 0000 0000 0000 0010 0101
 ==> le résultat vaut 37 en décimal
Le OU binaire.
Syntaxe.
 "exp1 | exp2"
Sémantique.
Le résultat est obtenu en faisant un OU logique sur chaque bit de la représentation de exp1 avec le bit correspondant de la représentation de exp2.
Le OU logique a pour résultat 1 si l'un des deux bits correspondant en entrée est à 1 (pour 1-1, 1-0 ou 0-1), et sinon 0 (pour 0-0).
Exemple.
using namespace std;
int main()
 int a = 53;
 int b = 167;
 int c = a | b;
 cout « "c vaut " « c « endl;
 return 0;
Exécution.
 c vaut 183
Explications.
 53 s'écrit en binaire 0000 0000 0000 00000 0000 0000 0011 0101
 167 s'écrit en binaire 0000 0000 0000 00000 0000 0000 1010 0111
 OU binaire 0000 0000 0000 00000 0000 0000 1011 0111
 ==> le résultat vaut 183 en décimal
Le OU exclusif binaire.
Syntaxe.
 "exp1 ^ exp2"
Sémantique.
Le résultat est obtenu est faisant un OU exclusif sur chaque bit de la représentation de exp1 avec le bit correspondant de la représentation de exp2.
Le OU exclusif logique a pour résultat 1 si les deux bits correspondant en entrée sont différents (pour 1-0 ou 0-1), et sinon 0 (pour 1-1 ou 0-0).
Exemple.
using namespace std;
int main()
 int a = 53;
 int b = 167;
 int c = a ^ b;
 cout « "c vaut " « c « endl;
 return 0;
Exécution.
 c vaut 146
Explications.
 53 s'écrit en binaire 0000 0000 0000 00000 0000 0000 0011 0101
 167 s'écrit en binaire 0000 0000 0000 00000 0000 0000 1010 0111
 OU exclusif binaire 0000 0000 0000 00000 0000 0000 1001 0010
 ==> le résultat vaut 146 en décimal
Le NON binaire.
Syntaxe.
 "~exp"
Sémantique.
Le résultat est obtenu en inversant tous les bits de la représentation de exp. Le 1 devient 0 et "vice versa".
Exemple.
using namespace std;
int main()
 int a = 53;
 int b = ~a;
 cout « "b vaut " « b « endl;
 return 0;
Exécution.
 b vaut -54
Explications.
 53 s'écrit en binaire 0000 0000 0000 0000 0000 0000 0011 0101
 NON binaire 1111 1111 1111 1111 1111 1111 1100 1010
 ==> le résultat vaut -54 en décimal (signed int)
 ou 4294967242 (unsigned int)
Opérations booléennes.
Comparaisons usuelles.
Les comparaissons usuelles s'effectuent selon la syntaxe "a symbole b", "symbole" désignant le test effectué :
Le ET logique.
Syntaxe.
 "condition1 && condition2"
Sémantique.
Le ET logique est vrai si à la fois les condition1 et condition2 sont vraies . Il est faux dans le cas contraire.
Attention : "condition2" est évalué uniquement si "condition1" a la valeur codice_10 (différente de zéro). Cette évaluation élimine l’évaluation inutile de "condition2" puisque l’expression estcodice_11
Le OU logique.
Syntaxe.
"condition1 || condition2"
Sémantique.
Le OU logique est vrai si au moins une des 2 conditions "condition1" ou "condition2" est vraie . Il est faux dans le cas contraire.
Attention : Le "conditions2" est évalué uniquement si "condition1" a la valeur codice_12 . Il s’agit là aussi d' "une évaluation de court-circuit" .
Le NON logique.
Syntaxe.
"!(condition)"
Sémantique.
Le NON logique inverse la valeur de "condition": si "condition" vaut codice_10 le résultat vaut codice_14. Si "condition" vaut codice_14 le résultat vaut codice_10.
Exemples d'utilisation des opérateurs booléens.
bool b;
int u = 18;
b = !( (u>20 || (u<0)));
codice_2 vaut codice_10.
bool b = ! false ; // -> b vaut true
b = ! true ; // -> b vaut false
Affectation avec opérateur.
Il existe toute une gamme d'opérateurs permettant d'effectuer une opération (une addition par exemple) avec le contenu d'une variable et de mettre le résultat dans cette même variable. Ainsi il sera plus pratique d'écrire codice_19 que d'écrire codice_20.
Une opération du type
 a "opérateur"= "expression" ;
équivaut à :
 a = a "opérateur" ("expression") ;
L'opérateur +=.
Syntaxe.
 "identificateur+=expression"
Sémantique.
Cet opérateur ajoute à la variable "identificateur" la valeur de "expression" et stocke le résultat dans la variable identificateur.
Exemple.
using namespace std;
int main()
 int a = 80;
 int b = 70;
 b += a;
 cout « "La valeur de b est : " « b « endl;
 return 0;
Exécution.
 La valeur de b est 150
Autres opérateurs.
Sur le même modèle, on peut utiliser les opérateurs suivants : -=, *=, /=, %=, »=,«=, &=, |= et ^=.
Priorité des opérateurs.
Comme en mathématique, tous les opérateurs n'ont pas la même priorité.
Par exemple, l'expression codice_21 retournera la valeur codice_22 car l'opérateur codice_23 a une plus grande priorité et est évalué avant l'opérateur codice_24. L'expression est donc équivalent à codice_25.
Les parenthèses permettent de modifier les priorités en encadrant ce qu'il faut évaluer avant. Ainsi l'expression codice_26 retournera la valeur codice_27.
La liste complète des opérateurs du C++.
La liste ci-dessous présente les différents opérateurs du C++ avec leur associativité dans l'ordre de leur priorité (du premier évalué au dernier). Les opérateurs situés dans le même bloc ont la même priorité.
Les opérateurs en rouge ne peuvent être surchargés.