Maîtriser les opérateurs relationnels et logiques C++ :un 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 ou false valeurs.

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

Opérateurs relationnels C++

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

// checks if a is greater than b
a > b;

Ici, > est un opérateur relationnel. Il vérifie si a est supérieur à b ou non.

Si la relation est vraie , il renvoie 1 alors que si la relation est fausse , il renvoie 0 .

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

Opérateur Signification Exemple == Est égal à 3 == 5 nous donne faux != Différent de 3 != 5 nous donne vrai > Supérieur à 3 > 5 nous donne faux < Moins de 3 < 5 nous donne vrai >= Supérieur ou égal à 3 >= 5 donnez-nous faux <= Less Than or Equal To 3 <= 5 nous donne vrai

==Opérateur

L'égal à == l'opérateur revient

• 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

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

!=Opérateur

Le différent de != l'opérateur revient

• 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

Le supérieur à > l'opérateur revient

• true - si l'opérande de gauche est supérieur à celui de droite
• false - si l'opérande de gauche est inférieur à celui de droite

Par exemple,

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

L'opérateur inférieur à < retourne

• true - si l'opérande de gauche est inférieur à celui de droite
• false - si l'opérande gauche est supérieur à celui de droite

Par exemple,

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

>=Opérateur

Le supérieur ou égal à >= l'opérateur revient

• true - si l'opérande de gauche est supérieur ou égal à celui de droite
• false - si l'opérande de gauche est inférieur à 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 à <= retourne

• true - si l'opérande de gauche est inférieur ou égal à celui de droite
• false - si l'opérande gauche est supérieur à celui de droite

Par exemple,

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

Afin d'apprendre comment les opérateurs relationnels peuvent être utilisés avec des chaînes, reportez-vous à notre tutoriel ici.

Opérateurs logiques C++

Nous utilisons des opérateurs logiques pour vérifier si une expression est vraie ou faux . Si l'expression est vrai , il renvoie 1 alors que si l'expression est fausse , il renvoie 0 .

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

Opérateur ET logique C++

L'opérateur logique ET && retourne

• 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 &&

Laissez un et b être deux opérandes. 0 représente faux tandis que 1 représente vrai . Ensuite,

un b a &&b 0 0 0 0 1 0 1 0 0 1 1 1

Comme nous pouvons le voir dans la table de vérité ci-dessus, le && l'opérateur renvoie vrai uniquement si les deux a et b sont vrais.

Remarque :L'opérateur ET logique && ne doit pas être confondu avec l'opérateur Bitwise AND & .

Exemple 1 :Opérateur OR C++

// C++ program demonstrating && operator truth table
#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 int variables a et b avec les valeurs 5 et 9 respectivement. Nous imprimons ensuite une expression logique

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

Ici, a == 0 est évalué à false car la valeur de a est 5 . a > b est également false puisque la valeur de a est inférieure à celle de b. On utilise alors l'opérateur AND && pour combiner ces deux expressions.

De la table de vérité de && opérateur, nous savons que false && false (c'est-à-dire 0 && 0 ) donne lieu à une évaluation de false (0 ). C'est le résultat que nous obtenons dans la sortie.

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

Opérateur OU logique C++

L'opérateur logique OU || retourne

• 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 || Opérateur

Laissez un et b être deux opérandes. Ensuite,

un b un || b 0 0 0 0 1 1 1 0 1 1 1 1

Comme nous pouvons le voir dans la table de vérité ci-dessus, le || l'opérateur renvoie false uniquement si les deux a et b sont faux.

Exemple 2 :Opérateur OR C++

// C++ program demonstrating || operator truth table
#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 int variables a et b avec les valeurs 5 et 9 respectivement. Nous imprimons ensuite une expression logique

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

Ici, a == 0 est évalué à false car la valeur de a est 5 . a > b est également false puisque la valeur de a est inférieure à celle de b. On utilise alors l'opérateur OR || pour combiner ces deux expressions.

De la table de vérité de || opérateur, nous savons que false || false (c'est-à-dire 0 || 0 ) donne lieu à une évaluation de false (0 ). C'est le résultat que nous obtenons dans la sortie.

Similarly, we evaluate three other expressions that fully demonstrate the truth table of || opérateur.

Opérateur NOT 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 vrai lorsque l'opérande est faux , et faux lorsque l'opérande est vrai .

Table de Vérité du ! Opérateur

Laissez un être un opérande. Ensuite,

Exemple 3 :C++ ! Opérateur

// C++ program demonstrating ! operator truth table
#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 un int variable a avec la valeur 5 . Nous imprimons ensuite une expression logique

!(a == 0) 

Ici, a == 0 est évalué à false car la valeur de a est 5 . Cependant, nous utilisons l'opérateur NOT ! sur a == 0 . Depuis a == 0 est évalué à false , le ! l'opérateur inverse les résultats de a == 0 et le résultat final est true .

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

Maîtriser les boucles imbriquées en C# :For, While et Do-While expliqués Manipulation de chaîne principale en C avec les fonctions de bibliothèque standard