Expresii condiționale

Expresiile condiționale reprezintă o anumită condiție și returnează o valoare de tip bool, adică valoarea true (dacă condiția este adevărată) sau valoarea false (dacă condiția este falsă). În expresiile condiționale sunt incluse operațiile de comparație și operațiile logice.

Operațiile de comparație

În limbajul de programare C++ există următoarele operații de comparație:

• == Operația „egal cu”. Returnează true dacă ambii operanzi sunt egali și false dacă nu sunt egali:

int a {10};
int b {4};
bool c {a == b};    // false
bool d {a == 10};   // true

• > Operația „mai mare decât”. Returnează true dacă primul operand este mai mare decât al doilea și false dacă primul operand este mai mic decât al doilea:

int a {10};
int b {4};
bool c {a > b};  // true

• < Operația „mai mic decât”. Returnează true dacă primul operand este mai mic decât al doilea și false dacă primul operand este mai mare decât al doilea:

bool c {10 < 4}; // false

• <= Operația „mai mic sau egal cu”. Returnează true dacă primul operand este mai mic sau egal cu al doilea și false dacă primul operand este mai mare decât al doilea:

bool c = 10 <= 4;    // false  
bool d = 10 <= 14;   // true

• >= Operația „mai mare sau egal cu”. Returnează true dacă primul operand este mai mare sau egal cu al doilea și false dacă primul operand este mai mic decât al doilea:

bool c = 10 >= 4;    // true  
bool d = 10 >= 14;   // false

• != Operația „diferit de”. Returnează true dacă primul operand nu este egal cu al doilea și false dacă ambii operanzi sunt egali:

bool c {10 != 4};   // true  
bool d = 4 != 4;    // false

Trebuie menționat că, dacă afișăm o valoare de tip bool în consolă, implicit se afișează 1 (dacă este true) și 0 (dacă este false):

#include <iostream> 
 
int main()
{
    int a {8};
    int b {11};
    bool c {a == b};    // false
    bool d {a != b};    // true
    std::cout << "c = " << c << std::endl;  // c = 0
    std::cout << "d = " << d << std::endl;  // d = 1
}

De obicei, operațiile de comparație sunt utilizate în construcții condiționale de tip if...else, care vor fi analizate în continuare.

Operații logice

Operațiile logice sunt utilizate de obicei pentru a combina mai multe operații de comparație. În categoria operațiilor logice intră următoarele:

• ! (negație) Operator unar care returnează true dacă operandul este false. Dacă operandul este true, operatorul returnează false.

bool a {true};
bool b {!a};    // false
bool c {!b};    // true

• && (conjuncție, AND logic) Returnează true dacă ambii operanzi sunt diferiți de false. Returnează false dacă cel puțin un operand este false.

bool a {true};
bool b {false};
bool c {a && b};    // false
bool d {a && true}; // true

• || (disjuncție, OR logic) Returnează true dacă cel puțin unul dintre operanzi este true. Returnează false doar dacă ambii operanzi sunt false.

bool a {true};
bool b {false};
bool c {a || b};        // true
bool d {b || false};    // false

• ^ (XOR sau eXclusive OR) Returnează true dacă operanzii au valori diferite. Returnează false dacă ambii operanzi sunt egali.cppCopyEdit

bool a {true};
bool b {false};
bool c {a ^ b};          // true
bool d {b ^ false};      // false
bool e {a ^ true};       // false

Operațiile logice sunt utile pentru a combina operații de comparație sau alte expresii logice:

#include <iostream> 
 
int main()
{
    int a {5};
    int b {8};
    bool result1 = a ==5 && b > 8;  // dacă atât a == 5, cât și b > 8
    bool result2 = a ==5 || b > 8;  // dacă fie a == 5, fie b > 8 (sau ambele sunt adevărate)
    bool result3 = a ==5 ^ b > 8;   // dacă ambii operanzi returnează valori diferite
 
    std::cout << "(a ==5 && b > 8) - " << std::boolalpha << result1 << std::endl;
    std::cout << "(a ==5 || b > 8) - " << std::boolalpha << result2 << std::endl;
    std::cout << "(a ==5 ^ b > 8) - " << std::boolalpha << result3 << std::endl;
}

Trebuie avut în vedere că operațiile de comparație au o prioritate mai mare decât operațiile logice. Prin urmare, în expresia a == 5 && b > 8, se vor executa mai întâi subexpresiile — operațiile de comparație a == 5 și b > 8, iar abia apoi operația de conjuncție logică (&&).

În acest caz, prima condiție a == 5 && b > 8 va fi adevărată doar dacă ambele operații de comparație sunt adevărate în același timp. Condiția a == 5 || b > 8 va fi adevărată dacă cel puțin una dintre operațiile de comparație returnează true.

În consecință, vom obține următorul output în consolă:

(a ==5 && b > 8) - false
(a ==5 || b > 8) - true
(a ==5 ^ b > 8) - true

Trebuie menționat că operatorii logici && și || reprezintă operatori cu evaluare scurtcircuitată (short-circuit evaluation). Aceasta înseamnă că, dacă primul operand este suficient pentru a determina rezultatul întregii expresii, atunci al doilea operand nu este evaluat deloc. Spre exemplu, să luăm următoarea operație:

int a {5};
int b {8};
bool result1 = a ==6 && b ==8;

Primul operand, care reprezintă expresia a == 6, returnează false. În acest caz, pentru operația && nu are sens să se evalueze al doilea operand, deoarece rezultatul operației va fi oricum egal cu false.

Situația este similară cu operația ||:

int a {5};
int b {8};
bool result1 = a ==5 || b ==0;

Primul operand, care reprezintă expresia a == 5, returnează true. În acest cas, pentru operația || nu are sens să se evalueze al doilea operand, deoarece rezultatul operației va fi oricum egal cu true.