Maîtriser les opérateurs relationnels et logiques en C++ : guide clair pour la prise de décision

En C++, les opérateurs relationnels et logiques comparent deux ou plusieurs opérandes et renvoient soit true soit false.

Nous utilisons ces opérateurs dans la prise de décision.

Opérateurs relationnels C++

Un opérateur relationnel vérifie 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 renvoie 1 ; si elle est false, il renvoie 0.

Le tableau suivant résume les opérateurs relationnels utilisés en C++.

Opérateur ==

L'opérateur égal à == renvoie

• true - si les deux opérandes sont égaux ou identiques
• false - si les opérandes sont inégaux

Par exemple,

int x = 10; int y = 15; int z = 10; x == y // false x == z // true

Note : L'opérateur relationnel == n'est pas le même que l'opérateur d'affectation =. L'opérateur d'affectation = assigne une valeur à une variable, constante, tableau ou vecteur. Il ne compare pas deux opérandes.

Opérateur !=

L'opérateur différent de != renvoie

• true - si les deux opérandes sont inégaux
• false - si les deux opérandes sont égaux.

Par exemple,

int x = 10; int y = 15; int z = 10; x != y // true x != z // false

Opérateur >

L'opérateur supérieur à > renvoie

• true - si l'opérande de gauche est plus grand que celui de droite
• false - si l'opérande de gauche est plus petit que celui de droite

Par exemple,

int x = 10; int y = 15; x > y // false y > x // true

Opérateur <

L'opérateur inférieur à < renvoie

• true - si l'opérande de gauche est plus petit que celui de droite
• false - si l'opérande de gauche est plus grand que celui de droite

Par exemple,

int x = 10; int y = 15; x < y // true y < x // false

Opérateur >=

L'opérateur supérieur ou égal à >= renvoie

• true - si l'opérande de gauche est soit plus grand que, soit égal à celui de droite
• false - si l'opérande de gauche est plus petit que celui de droite

Par exemple,

int x = 10; int y = 15; int z = 10; x >= y // false y >= x // true z >= x // true

Opérateur <=

L'opérateur inférieur ou égal à <= renvoie

• true - si l'opérande de gauche est soit plus petit que, soit égal à celui de droite
• false - si l'opérande de gauche est plus grand que celui de droite

Par exemple,

int x = 10; int y = 15; x <= y // true y <= x // false

Pour apprendre comment les opérateurs relationnels peuvent être utilisés avec les chaînes de caractères, consultez notre tutoriel ici.

Opérateurs logiques C++

Nous utilisons les opérateurs logiques pour vérifier si une expression est true ou false. Si l'expression est true, elle renvoie 1 ; si elle est false, elle renvoie 0.

Opérateur ET logique C++ (&&)

L'opérateur ET logique && renvoie

• true - si et seulement si tous les opérandes sont true.
• false - si un ou plusieurs opérandes sont false.

Table de vérité de l'opérateur &&

Soit a et b deux opérandes. 0 représente false tandis que 1 représente true. Alors,

Comme on le voit dans la table de vérité, l'opérateur && renvoie true seulement si a et b sont tous les deux true.

Note : L'opérateur ET logique && ne doit pas être confondu avec l'opérateur ET bit à bit &.

Exemple 1 : Opérateur ET logique C++

// Programme C++ démontrant la table de vérité de l'opérateur && #include <iostream> using namespace std; int main() { int a = 5; int b = 9; // false && false = false cout << ((a == 0) && (a > b)) << endl; // false && true = false cout << ((a == 0) && (a < b)) << endl; // true && false = false cout << ((a == 5) && (a > b)) << endl; // true && true = true cout << ((a == 5) && (a < b)) << endl; return 0; }

Sortie

 0 0 0 1

Dans ce programme, nous déclarons et initialisons deux variables int a et b avec les valeurs 5 et 9 respectivement. Nous affichons ensuite une expression logique

((a == 0) && (a > b))

Ici, a == 0 évalue à false car la valeur de a est 5. a > b est aussi false puisque la valeur de a est inférieure à celle de b. Nous utilisons ensuite l'opérateur ET && pour combiner ces deux expressions.

D'après la table de vérité de l'opérateur &&, nous savons que false && false (i.e. 0 && 0) résulte en une évaluation de false (0). C'est le résultat obtenu dans la sortie.

De même, nous évaluons trois autres expressions qui démontrent pleinement la table de vérité de l'opérateur &&.

Opérateur OU logique C++ (||)

L'opérateur OU logique || renvoie

• true - si un ou plusieurs des opérandes sont true.
• false - si et seulement si tous les opérandes sont false.

Table de vérité de l'opérateur ||

Soit a et b deux opérandes. Alors,

Comme on le voit dans la table de vérité, l'opérateur || renvoie false seulement si a et b sont tous les deux false.

Exemple 2 : Opérateur OU logique C++

// Programme C++ démontrant la table de vérité de l'opérateur || #include <iostream> using namespace std; int main() { int a = 5; int b = 9; // false || false = false cout << ((a == 0) || (a > b)) << endl; // false || true = true cout << ((a == 0) || (a < b)) << endl; // true || false = true cout << ((a == 5) || (a > b)) << endl; // true || true = true cout << ((a == 5) || (a < b)) << endl; return 0; }

Sortie

 0 1 1 1

Dans ce programme, nous déclarons et initialisons deux variables int a et b avec les valeurs 5 et 9 respectivement. Nous affichons ensuite une expression logique

((a == 0) || (a > b))

Ici, a == 0 évalue à false car la valeur de a est 5. a > b est aussi false puisque la valeur de a est inférieure à celle de b. Nous utilisons ensuite l'opérateur OU || pour combiner ces deux expressions.

D'après la table de vérité de l'opérateur ||, nous savons que false || false (i.e. 0 || 0) résulte en une évaluation de false (0). C'est le résultat obtenu dans la sortie.

De même, nous évaluons trois autres expressions qui démontrent pleinement la table de vérité de l'opérateur ||.

Opérateur NON logique C++ (!)

L'opérateur NON logique ! est un opérateur unaire, c'est-à-dire qu'il ne prend qu'un seul opérande.

Il renvoie true quand l'opérande est false, et false quand l'opérande est true.

Table de vérité de l'opérateur !

Soit a un opérande. Alors,

Exemple 3 : Opérateur NON logique C++

// Programme C++ démontrant la table de vérité de l'opérateur ! #include <iostream> using namespace std; int main() { int a = 5; // !false = true cout << !(a == 0) << endl; // !true = false cout << !(a == 5) << endl; return 0; }

Sortie

 1 0

Dans ce programme, nous déclarons et initialisons une variable int a avec la valeur 5. Nous affichons ensuite une expression logique

!(a == 0) 

Ici, a == 0 évalue à false car la valeur de a est 5. Cependant, nous utilisons l'opérateur NON ! sur a == 0. Puisque a == 0 évalue à false, l'opérateur ! inverse le résultat de a == 0 et le résultat final est true.

De même, l'expression !(a == 5) renvoie finalement false car a == 5 est true.