Beheersing van C++ relationele en logische operatoren:een duidelijke gids voor besluitvorming

In C++ vergelijken relationele en logische operatoren twee of meer operanden en retourneren true of false waarden.

We gebruiken deze operatoren bij de besluitvorming.

C++ relationele operators

Een relationele operator wordt gebruikt om de relatie tussen twee operanden te controleren. Bijvoorbeeld

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

Hier > is een relationele operator. Het controleert of a groter is dan b of niet.

Als de relatie waar is , retourneert het 1 terwijl als de relatie onwaar is , retourneert het 0 .

De volgende tabel geeft een overzicht van de relationele operatoren die in C++ worden gebruikt.

Bediener Betekenis Voorbeeld == Is gelijk aan 3 == 5 geeft ons false != Niet gelijk aan 3 != 5 geeft ons waar > Groter dan 3 > 5 geeft ons false < Minder dan 3 < 5 geeft ons waar >= Groter dan of gelijk aan 3 >= 5 geef ons false <= Kleiner dan of gelijk aan 3 <= 5 geeft ons waar

==Operator

Het is gelijk aan == operator retourneert

• true - als beide operanden gelijk of hetzelfde zijn
• false - als de operanden ongelijk zijn

Bijvoorbeeld

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

Opmerking: De relationele operator == is niet hetzelfde als de toewijzingsoperator = . De toewijzingsoperator = wijst een waarde toe aan een variabele, constante, array of vector. Er worden geen twee operanden met elkaar vergeleken.

!=Operator

Het is niet gelijk aan != operator retourneert

• true - als beide operanden ongelijk zijn
• false - als beide operanden gelijk zijn.

Bijvoorbeeld

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

> Operator

Hoe groter dan > operator retourneert

• true - als de linker operand groter is dan de rechter
• false - als de linker operand kleiner is dan de rechter

Bijvoorbeeld

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

De kleiner dan-operator < retourneert

• true - als de linker operand kleiner is dan de rechter
• false - als de linker operand groter is dan rechts

Bijvoorbeeld

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

>=Operator

Hoe groter dan of gelijk aan >= operator retourneert

• true - als de linker operand groter is dan of gelijk is aan de rechter
• false - als de linker operand kleiner is dan de rechter

Bijvoorbeeld

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

<=Operator

De operator kleiner dan of gelijk aan <= retourneert

• true - als de linker operand kleiner is dan of gelijk is aan de rechter
• false - als de linker operand groter is dan rechts

Bijvoorbeeld

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

Raadpleeg onze tutorial hier om te leren hoe relationele operatoren met strings kunnen worden gebruikt.

C++ Logische operators

We gebruiken logische operatoren om te controleren of een expressie waar is of onwaar . Als de expressie waar is , retourneert het 1 terwijl als de expressie false is , retourneert het 0 .

Bediener Voorbeeld Betekenis && expressie1 && uitdrukking 2 Logische AND.
alleen waar als alle operanden waar zijn. || expressie1 || uitdrukking 2 Logische OR.
true als ten minste één van de operanden waar is. ! ! uitdrukking Logisch NIET.
alleen waar als de operand onwaar is.

C++ Logische AND-operator

De logische AND-operator && retourneert

• true - als en slechts dan als alle operanden zijn true .
• false - if een of meer operanden zijn false .

Waarheidstabel van &&Operator

Laat a en b twee operanden zijn. 0 vertegenwoordigt onwaar terwijl 1 vertegenwoordigt waar . Dan

een b a &&b 0 0 0 0 1 0 1 0 0 1 1 1

Zoals we uit de waarheidstabel hierboven kunnen zien, is de && operator retourneert alleen waar als beide a en b zijn waar.

Opmerking:de logische AND-operator && moet niet worden verward met de Bitwise AND-operator & .

Voorbeeld 1:C++ OR-operator

// 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;
}

Uitvoer

0
0
0
1

In dit programma declareren en initialiseren we twee int variabelen a en b met de waarden 5 en 9 respectievelijk. Vervolgens printen we een logische uitdrukking

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

Hier a == 0 evalueert naar false aangezien de waarde van a 5 is . a > b is ook false omdat de waarde van a kleiner is dan die van b. We gebruiken dan de AND-operator && om deze twee uitdrukkingen te combineren.

Uit de waarheidstabel van && operator, we weten dat false && false (d.w.z. 0 && 0 ) resulteert in een evaluatie van false (0 ). Dit is het resultaat dat we krijgen in de uitvoer.

Op dezelfde manier evalueren we drie andere uitdrukkingen die de waarheidstabel van de && volledig demonstreren exploitant.

C++ Logische OR-operator

De logische OR-operator || retourneert

• true - als een of meer operanden zijn true .
• false - als en slechts dan als alle operanden zijn false .

Waarheidstabel van || Operator

Laat a en b twee operanden zijn. Dan

een b een || b 0 0 0 0 1 1 1 0 1 1 1 1

Zoals we uit de waarheidstabel hierboven kunnen zien, is de || operator retourneert alleen false als beide a en b zijn vals.

Voorbeeld 2:C++ OR-operator

// 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;
}

Uitvoer

0
1
1
1

In dit programma declareren en initialiseren we twee int variabelen a en b met de waarden 5 en 9 respectievelijk. Vervolgens printen we een logische uitdrukking

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

Hier a == 0 evalueert naar false aangezien de waarde van a 5 is . a > b is ook false omdat de waarde van a kleiner is dan die van b. We gebruiken dan de OR-operator || om deze twee uitdrukkingen te combineren.

Uit de waarheidstabel van || operator, we weten dat false || false (d.w.z. 0 || 0 ) resulteert in een evaluatie van false (0 ). Dit is het resultaat dat we krijgen in de uitvoer.

Op dezelfde manier evalueren we drie andere uitdrukkingen die de waarheidstabel van || volledig demonstreren exploitant.

C++ Logische NOT-operator !

De logische NOT-operator ! is een unaire operator, dat wil zeggen dat er slechts één operand nodig is.

Het retourneert true wanneer de operand false is , en onwaar wanneer de operand waar is .

Waarheidstabel van de ! Operator

Laat a een operand zijn. Dan

Voorbeeld 3:C++ ! Operator

// 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;
}

Uitvoer

1
0

In dit programma declareren en initialiseren we een int variabele a met de waarde 5 . Vervolgens printen we een logische uitdrukking

!(a == 0) 

Hier a == 0 evalueert naar false aangezien de waarde van a 5 is . We gebruiken echter de NOT-operator ! op a == 0 . Sinds a == 0 evalueert naar false , de ! operator keert de resultaten van a == 0 om en het eindresultaat is true .

Op dezelfde manier geldt de uitdrukking !(a == 5) retourneert uiteindelijk false omdat a == 5 is true .