Maîtriser les opérateurs C++ : Guide complet avec exemples pratiques

Opérateurs C++

Dans ce tutoriel, nous apprendrons les différents types d'opérateurs en C++ avec l'aide d'exemples. En programmation, un opérateur est un symbole qui opère sur une valeur ou une variable.

Les opérateurs sont des symboles qui effectuent des opérations sur des variables et des valeurs. Par exemple, + est un opérateur utilisé pour l'addition, tandis que - est un opérateur utilisé pour la soustraction.

Les opérateurs en C++ peuvent être classés en 6 types :

1. Opérateurs arithmétiques
2. Opérateurs d'affectation
3. Opérateurs relationnels
4. Opérateurs logiques
5. Opérateurs bit à bit
6. Autres opérateurs

---

1. Opérateurs arithmétiques C++

Les opérateurs arithmétiques sont utilisés pour effectuer des opérations arithmétiques sur des variables et des données. Par exemple,

a + b;

Ici, l'opérateur + est utilisé pour additionner deux variables a et b. De même, il existe divers autres opérateurs arithmétiques en C++.

Opérateur	Opération
+	Addition
-	Soustraction
*	Multiplication
/	Division
%	Opération modulo (reste après division)

---

Exemple 1 : Opérateurs arithmétiques

#include <iostream>
using namespace std;
int main() {
    int a, b;
    a = 7;
    b = 2;
    // affichage de la somme de a et b
    cout << "a + b = " << (a + b) << endl;
    // affichage de la différence de a et b
    cout << "a - b = " << (a - b) << endl;
    // affichage du produit de a et b
    cout << "a * b = " << (a * b) << endl;
    // affichage de la division de a par b
    cout << "a / b = " << (a / b) << endl;
    // affichage du modulo de a par b
    cout << "a % b = " << (a % b) << endl;
    return 0;
}

Sortie

a + b = 9
a - b = 5
a * b = 14
a / b = 3
a % b = 1

Ici, les opérateurs +, - et * calculent l'addition, la soustraction et la multiplication respectivement comme on pourrait s'y attendre.

Opérateur de division /

Notez l'opération (a / b) dans notre programme. L'opérateur / est l'opérateur de division.

Comme nous pouvons le voir dans l'exemple ci-dessus, si un entier est divisé par un autre entier, nous obtenons le quotient. Cependant, si le diviseur ou le dividende est un nombre à virgule flottante, nous obtenons le résultat en décimales.

En C++, 7/2 est 3
7.0 / 2 est 3.5
7 / 2.0 est 3.5
7.0 / 2.0 est 3.5

Opérateur modulo %

L'opérateur modulo % calcule le reste. Quand a = 9 est divisé par b = 4, le reste est 1.

Note : L'opérateur % ne peut être utilisé qu'avec des entiers.

---

Opérateurs d'incrémentation et décrémentation

C++ fournit aussi les opérateurs d'incrémentation et décrémentation : ++ et -- respectivement.

• ++ augmente la valeur de l'opérande de 1
• -- la diminue de 1

Par exemple,

int num = 5;
// opérateur d'incrémentation
++num; // 6

Ici, le code ++num; augmente la valeur de num de 1.

---

Exemple 2 : Opérateurs d'incrémentation et décrémentation

// Fonctionnement des opérateurs d'incrémentation et décrémentation
#include <iostream>
using namespace std;
int main() {
    int a = 10, b = 100, resultat_a, resultat_b;
    // incrémentation de a de 1 et stockage du résultat dans resultat_a
    resultat_a = ++a;
    cout << "resultat_a = " << resultat_a << endl;
    // décrémentation de b de 1 et stockage du résultat dans resultat_b
    resultat_b = --b;
    cout << "resultat_b = " << resultat_b << endl;
    return 0;
}

Sortie

resultat_a = 11
resultat_b = 99

Dans le programme ci-dessus, nous avons utilisé les opérateurs ++ et -- comme préfixes (++a et --b). Cependant, nous pouvons aussi utiliser ces opérateurs comme postfixes (a++ et b--).

Pour en savoir plus, visitez les opérateurs d'incrémentation et décrémentation.

---

2. Opérateurs d'affectation C++

En C++, les opérateurs d'affectation sont utilisés pour assigner des valeurs aux variables. Par exemple,

// assigner 5 à a
a = 5;

Ici, nous avons assigné une valeur de 5 à la variable a.

Opérateur	Exemple	Équivalent à
=	a = b;	a = b;
+=	a += b;	a = a + b;
-=	a -= b;	a = a - b;
*=	a *= b;	a = a * b;
/=	a /= b;	a = a / b;
%=	a %= b;	a = a % b;

---

Exemple 3 : Opérateurs d'affectation

#include <iostream>
using namespace std;
int main() {
    int a, b;
    // 2 est assigné à a
    a = 2;
    // 7 est assigné à b
    b = 7;
    cout << "a = " << a << endl;
    cout << "b = " << b << endl;
    cout << "\nAprès a += b;" << endl;
    // assignation de la somme de a et b à a
    a += b; // a = a + b
    cout << "a = " << a << endl;
    return 0;
}

Sortie

a = 2
b = 7
Après a += b;
a = 9

---

3. Opérateurs relationnels C++

Un opérateur relationnel est utilisé pour vérifier la relation entre deux opérandes. Par exemple,

// vérifie si a est plus grand que b
a > b;

Ici, > est un opérateur relationnel. Il vérifie si a est plus grand que b ou non.

Si la relation est true, il retourne 1 alors que si la relation est false, il retourne 0.

Opérateur	Signification	Exemple
==	Est Égal À	3 == 5 donne false
!=	N'est Pas Égal À	3 != 5 donne true
>	Plus Grand Que	3 > 5 donne false
<	Plus Petit Que	3 < 5 donne true
>=	Plus Grand Ou Égal À	3 >= 5 donne false
<=	Plus Petit Ou Égal À	3 <= 5 donne true

---

Exemple 4 : Opérateurs relationnels

#include <iostream>
using namespace std;
int main() {
    int a, b;
    a = 3;
    b = 5;
    bool resultat;
    resultat = (a == b); // false
    cout << "3 == 5 est " << resultat << endl;
    resultat = (a != b); // true
    cout << "3 != 5 est " << resultat << endl;
    resultat = a > b; // false
    cout << "3 > 5 est " << resultat << endl;
    resultat = a < b; // true
    cout << "3 < 5 est " << resultat << endl;
    resultat = a >= b; // false
    cout << "3 >= 5 est " << resultat << endl;
    resultat = a <= b; // true
    cout << "3 <= 5 est " << resultat << endl;
    return 0;
}

Sortie

3 == 5 est 0
3 != 5 est 1
3 > 5 est 0
3 < 5 est 1
3 >= 5 est 0
3 <= 5 est 1

Note : Les opérateurs relationnels sont utilisés dans la prise de décision et les boucles.

---

4. Opérateurs logiques C++

Les opérateurs logiques sont utilisés pour vérifier si une expression est true ou false. Si l'expression est true, elle retourne 1 alors que si l'expression est false, elle retourne 0.

Opérateur	Exemple	Signification
&&	expression1 && expression2	ET logique. Vrai seulement si tous les opérandes sont vrais.
||	expression1 || expression2	OU logique. Vrai si au moins un des opérandes est vrai.
!	!expression	NON logique. Vrai seulement si l'opérande est faux.

En C++, les opérateurs logiques sont couramment utilisés dans la prise de décision. Pour mieux comprendre les opérateurs logiques, voyons les exemples suivants :

Supposons, a = 5, b = 8
Alors, (a > 3) && (b > 5) évalue à true
(a > 3) && (b < 5) évalue à false
(a > 3) || (b > 5) évalue à true
(a > 3) || (b < 5) évalue à true
(a < 3) || (b < 5) évalue à false
!(a < 3) évalue à true
!(a > 3) évalue à false

---

Exemple 5 : Opérateurs logiques

#include <iostream>
using namespace std;
int main() {
    bool resultat;
    resultat = (3 != 5) && (3 < 5); // true
    cout << "(3 != 5) && (3 < 5) est " << resultat << endl;
    resultat = (3 == 5) && (3 < 5); // false
    cout << "(3 == 5) && (3 < 5) est " << resultat << endl;
    resultat = (3 == 5) && (3 > 5); // false
    cout << "(3 == 5) && (3 > 5) est " << resultat << endl;
    resultat = (3 != 5) || (3 < 5); // true
    cout << "(3 != 5) || (3 < 5) est " << resultat << endl;
    resultat = (3 != 5) || (3 > 5); // true
    cout << "(3 != 5) || (3 > 5) est " << resultat << endl;
    resultat = (3 == 5) || (3 > 5); // false
    cout << "(3 == 5) || (3 > 5) est " << resultat << endl;
    resultat = !(5 == 2); // true
    cout << "!(5 == 2) est " << resultat << endl;
    resultat = !(5 == 5); // false
    cout << "!(5 == 5) est " << resultat << endl;
    return 0;
}

Sortie

(3 != 5) && (3 < 5) est 1
(3 == 5) && (3 < 5) est 0
(3 == 5) && (3 > 5) est 0
(3 != 5) || (3 < 5) est 1
(3 != 5) || (3 > 5) est 1
(3 == 5) || (3 > 5) est 0
!(5 == 2) est 1
!(5 == 5) est 0

Explication du programme d'opérateurs logiques

• (3 != 5) && (3 < 5) évalue à 1 car les deux opérandes (3 != 5) et (3 < 5) sont 1 (vrai).
• (3 == 5) && (3 < 5) évalue à 0 car l'opérande (3 == 5) est 0 (faux).
• (3 == 5) && (3 > 5) évalue à 0 car les deux opérandes (3 == 5) et (3 > 5) sont 0 (faux).
• (3 != 5) || (3 < 5) évalue à 1 car les deux opérandes (3 != 5) et (3 < 5) sont 1 (vrai).
• (3 != 5) || (3 > 5) évalue à 1 car l'opérande (3 != 5) est 1 (vrai).
• (3 == 5) || (3 > 5) évalue à 0 car les deux opérandes (3 == 5) et (3 > 5) sont 0 (faux).
• !(5 == 2) évalue à 1 car l'opérande (5 == 2) est 0 (faux).
• !(5 == 5) évalue à 0 car l'opérande (5 == 5) est 1 (vrai).

---

5. Opérateurs bit à bit C++

En C++, les opérateurs bit à bit sont utilisés pour effectuer des opérations sur des bits individuels. Ils ne peuvent être utilisés qu'avec les types de données char et int.

Opérateur	Description
&	ET binaire
|	OU binaire
^	XOR binaire
~	Complément à un binaire
<<	Décalage gauche binaire
>>	Décalage droit binaire

Pour en savoir plus, visitez les opérateurs bit à bit C++.

---

6. Autres opérateurs C++

Voici une liste de quelques autres opérateurs courants disponibles en C++. Nous les apprendrons dans les tutoriels suivants.

Opérateur	Description	Exemple
sizeof	retourne la taille du type de données	sizeof(int); // 4
?:	retourne une valeur basée sur la condition	string resultat = (5 > 0) ? "pair" : "impair"; // "pair"
&	représente l'adresse mémoire de l'opérande	# // adresse de num
.	accède aux membres de variables struct ou objets de classe	s1.notes = 92;
->	utilisé avec les pointeurs pour accéder aux variables de classe ou struct	ptr->notes = 92;
<<	affiche la valeur de sortie	cout << 5;
>>	obtient la valeur d'entrée	cin >> num;