Construcția if-else și operatorul ternar
Construcția condițională if-else direcționează fluxul programului pe una dintre căile posibile în funcție de o condiție. Aceasta verifică dacă o condiție este adevărată, iar dacă este, execută un bloc de instrucțiuni. În forma sa cea mai simplă, construcția if are următorul format prescurtat:
if (condiție)
{
instrucțiuni;
}Ca și condiție se folosește o expresie condițională care returnează true sau false. Dacă condiția returnează true, se execută instrucțiunile care fac parte din blocul if. Dacă condiția returnează false, instrucțiunile respective nu se execută. Blocul de instrucțiuni este delimitat prin acolade. De exemplu:
#include <iostream>
int main()
{
int a {8};
if(a == 8)
{
std::cout << "a == 8" << std::endl;
}
std::cout << "End of program" << std::endl;
}Aici, condiția construcției if este expresia a == 8, adică verificăm dacă valoarea variabilei a este egală cu 8. Această condiție este adevărată și returnează true. În consecință, se va executa singura instrucțiune din blocul if, care va afișa în consolă șirul "a == 8". Iar rezultatul afișat în consolă va fi următorul:
a == 8
End of programDupă construcția if pot urma alte instrucțiuni ale programului, care se execută indiferent de condiție. Astfel, în exemplul de mai sus, după blocul if urmează instrucțiunea care afișează în consolă șirul "End of program".
Acum să vedem situația opusă:
#include <iostream>
int main()
{
int a {8};
if(a == 7)
{
std::cout << "a == 7" << std::endl;
}
std::cout << "End of program" << std::endl;
}Aici avem o altă condiție: a == 7, adică verificăm dacă valoarea variabilei a este egală cu 7. Dar variabila a NU este egală cu 7, prin urmare condiția este falsă și returnează false. În consecință, instrucțiunile din blocul if NU se execută. Iar afișarea în consolă va fi următoarea:
End of programTrebuie menționat că, dacă blocul de instrucțiuni conține o singură instrucțiune, atunci putem să nu folosim acoladele:
#include <iostream>
int main()
{
int a {8};
if(a == 8) // только одна инструкция
std::cout << "a == 8" << std::endl;
std::cout << "End of program" << std::endl;
}Se poate chiar plasa instrucțiunea pe aceeași linie cu condiția:
if(a == 8) std::cout << "a == 8" << std::endl;if..else
De asemenea, putem folosi forma completă a construcției if, care include operatorul else:
if (expresie_condiție)
{
instrucțiune_1
}
else
{
instrucțiune_2
}
După operatorul else putem specifica un set de instrucțiuni care se execută dacă condiția din operatorul if returnează false. Adică, dacă condiția este adevărată, se execută instrucțiunile de după operatorul if, iar dacă această expresie este falsă, se execută instrucțiunile de după operatorul else.
#include <iostream>
int main()
{
int n {21};
if (n > 22)
{
std::cout << "n > 22" << std::endl;
}
else
{
std::cout << "n <= 22" << std::endl;
}
}În acest caz, condiția n > 22 este falsă, adică returnează false, prin urmare se va executa blocul else. Și, în final, în consolă va fi afișat șirul "n <= 22".
if-else
Totuși, adesea este necesar să tratăm nu doar două variante alternative, ci mult mai multe. De exemplu, în cazul de mai sus pot fi identificate trei condiții: variabila n poate fi mai mare decât 22, mai mică decât 22 sau egală cu 22. Pentru a verifica condiții alternative, putem introduce expresii else if:
#include <iostream>
int main()
{
int n {21};
if (n > 22)
{
std::cout << "n > 22" << std::endl;
}
else if (n < 22)
{
std::cout << "n < 22" << std::endl;
}
else
{
std::cout << "n == 22" << std::endl;
}
}Adică, în acest caz, obținem trei ramuri posibile de execuție în program.
Astfel de condiții alternative, folosind expresia else if, pot fi introduse în număr mai mare decât unul:
#include <iostream>
int main()
{
int n {21};
if (n == 20)
{
std::cout << "n == 20" << std::endl;
}
else if(n==21)
{
std::cout << "n == 21" << std::endl;
}
else if(n==22)
{
std::cout << "n == 22" << std::endl;
}
else if(n==23)
{
std::cout << "n == 23" << std::endl;
}
}Dacă în blocul if, else sau else-if este necesar să se execute doar o singură instrucțiune, atunci acoladele pot fi omise:
#include <iostream>
int main()
{
int n {21};
if (n > 22)
std::cout << "n > 22" << std::endl;
else if (n < 22)
std::cout << "n < 22" << std::endl;
else
std::cout << "n == 22" << std::endl;
}Condiții întregi
Trebuie menționat că, dacă în loc de valori de tip bool sunt transmise numere întregi, acestea sunt convertite la tipul bool — pentru valorile zero se returnează false, iar pentru valorile diferite de zero — true, de exemplu:
#include <iostream>
int main()
{
int a {8};
// a = true
if(a) std::cout << "a = true" << std::endl;
else std::cout << "a = false" << std::endl;
int b {};
// b = false
if(b) std::cout << "b = true" << std::endl;
else std::cout << "b = false" << std::endl;
}Aici, variabila a este egală cu 8, așadar condiția if(a) va fi egală cu true. În schimb, variabila b este egală cu 0 în mod implicit, deci condiția din if(b) returnează false.
Construcții imbricate
Construcțiile if...else pot fi imbricate. De exemplu:
#include <iostream>
int main()
{
int a {5};
int b {8};
if(a==5)
{
if(b==8)
{
std::cout << "b == 8" << std::endl;
}
else
{
std::cout << "b != 8" << std::endl;
}
std::cout << "a == 5" << std::endl;
}
else
{
std::cout << "a != 5 " << std::endl;
}
}Aici, dacă a == 5, execuția trece la construcția if imbricată if(b == 8), care verifică condiția b == 8 și execută fie blocul if, fie blocul else.
Blocul if cu inițializarea unei variabile
Uneori, în construcția if, este necesar să definim o variabilă pentru diverse calcule intermediare. Putem face acest lucru direct în blocul de cod. Totuși, începând cu standardul C++17, limbajul C++ acceptă o formă specială a construcției if:
if (inițializare; condiție)
{
// instrucțiuni
}O astfel de formă acceptă de asemenea o condiție, doar că înaintea ei poate apărea și definirea și inițializarea unei variabile. De exemplu:
#include <iostream>
int main()
{
int a {5};
int b {3};
if(int c {a - b}; a > b)
{
std::cout << "a=" << a << "; c=" << c << std::endl;
}
else
{
std::cout << "b=" << b << "; c=" << c << std::endl;
}
}În acest caz, expresia de inițializare int c {a - b} reprezintă definirea și inițializarea variabilei c. Apoi urmează condiția a > b. Dacă aceasta este adevărată, atunci se execută instrucțiunea.
std::cout << "a=" << a << "; c=" << c << std::endl;altfel se execută instrucțiunea:
std::cout << "b=" << b << "; c=" << c << std::endl;Dar în ambele cazuri putem folosi variabila c. În afara construcției if-else, variabila c nu este disponibilă.
Un alt exemplu. Să presupunem că trebuie să determinăm dacă un număr se împarte la altul fără rest. Dacă există rest, atunci să-l afișăm în consolă:
#include <iostream>
int main()
{
int a {5};
int b {3};
if(int rem {a % b}; rem == 0)
{
std::cout << "a divisible by b" << std::endl;
}
else
{
std::cout << "remaining of a / b = " << rem << std::endl;
}
}În acest caz, în construcția if este definită variabila rem, care reprezintă restul împărțirii lui a la b.
Operatorul ternar
Operatorul ternar este într-un anumit sens similar cu construcția if-else. El primește trei operanzi în următorul format:
operand1? operand2 : operand3
Primul operand reprezintă condiția. Dacă această condiție este adevărată (egală cu true), atunci este ales/executat al doilea operand, care se află după simbolul ?. Dacă condiția nu este adevărată, atunci este ales/executat al treilea operand, care se află după două puncte :
De exemplu, să luăm următoarea construcție if-else:
#include <iostream>
int main()
{
int a {5};
int b {8};
int c{};
if(a > b)
{
c = a - b;
}
else
{
c = a + b;
}
std::cout << "c = " << c << std::endl; // c = 13
}Aici, dacă a este mai mare decât b, atunci c = a - b, altfel c = a + b. Acum să rescriem aceasta folosind operatorul ternar:
#include <iostream>
int main()
{
int a {5};
int b {8};
int c = a > b ? a - b : a + b;
std::cout << "c = " << c << std::endl; // c = 13
}Aici, primul operand al operatorului ternar este condiția a > b. Dacă această condiție este adevărată, atunci se returnează al doilea operand – rezultatul expresiei a - b. Dacă condiția nu este adevărată, se returnează al treilea operand – a + b. Iar operandul returnat este atribuit variabilei c.
Operatorul ternar nu este obligat să returneze o valoare; el poate pur și simplu să execute anumite acțiuni. De exemplu:
#include <iostream>
int main()
{
int a {5};
int b {8};
a > b ? std::cout << a-b : std::cout << a+b;
}Aici avem același prim operand – condiția. Dacă aceasta este adevărată, se execută al doilea operand – std::cout << a - b, iar dacă nu, atunci al treilea operand – std::cout << a + b.
În cadrul unui singur operator ternar pot fi combinate mai mulți alți operatori. De exemplu:
#include <iostream>
int main()
{
int a {5};
int b {8};
std::cout << (a < b ? "a is less than b" :
(a == b ? "a is equal to b" : "a is greater than b"));
}Aici, condiția este expresia a < b. Dacă aceasta este adevărată, se returnează al doilea operand – șirul "a is less than b". Dar dacă condiția nu este adevărată, se returnează al treilea operand, care la rândul său este un alt operator ternar: (a == b ? "a is equal to b" : "a is greater than b"). Aici este evaluată din nou o condiție – primul operand a == b. Dacă aceasta este adevărată, se returnează șirul "a is equal to b", iar dacă nu, atunci șirul "a is greater than b".
