Răspuns pe scurt
Într-o condiție cu o variabilă int, x == 5 compară valoarea lui x cu 5, fără să o modifice. x = 5 atribuie valoarea 5, iar condiția devine adevărată, deoarece 5 este diferit de zero.
Pentru a verifica dacă x are valoarea 5, scrie if (x == 5). Dacă x este de tip int, varianta cu un singur egal, if (x = 5), îi pune valoarea 5 și face condiția adevărată. Programul poate trece astfel pe ramura if chiar dacă x era 7.
Când începi instrucțiunea if la informatică, diferența se vede mai ușor dacă urmărești și ce rămâne în variabilă. În programul de mai jos, x pornește de la 7:
#include <iostream>
int main() {
int x = 7;
if (x = 5) {
std::cout << "ramura if\n";
} else {
std::cout << "ramura else\n";
}
std::cout << "x = " << x << '\n';
}
Programul afișează:
ramura if
x = 5
Ultima linie arată că x a devenit 5. Valoarea 7 s-a pierdut în timpul evaluării condiției.
Cum verifici dacă x este 5?
Înlocuiește doar condiția din program cu:
if (x == 5)== este operatorul de egalitate. Pentru valorile int din exemplu, compară ce se află în x cu 5, fără să modifice x. Rezultatul este false, fiindcă 7 și 5 sunt diferite. Cu această corectură, programul afișează:
ramura else
x = 7
Operatorul == dă un rezultat de tip bool: true când valorile sunt egale și false când sunt diferite. Acesta este sensul lui în secțiunea despre operatorii de egalitate din proiectul standardului C++.
Ce face un singur egal în condiție?
Pentru variabilele întregi din exemplu, = este operatorul de atribuire. Expresia x = 5 scrie 5 în x. În acest caz, if folosește valoarea lui x după atribuire. Poți urmări regula în secțiunea despre atribuire a aceluiași proiect de standard.
Pentru a alege ramura, rezultatul expresiei din condiție este convertit la bool: adevărat sau fals. Dacă rezultatul este un întreg, zero înseamnă fals, iar orice număr diferit de zero înseamnă adevărat. În primul program, valoarea este 5, deci se execută ramura if. Regulile sunt descrise în secțiunile despre condiții și conversia la bool.
Același efect al atribuirii explică și de ce ai nevoie să salvezi o valoare înainte să o înlocuiești la interschimbarea a două variabile în C++.
De ce un test cu x egal cu 5 poate ascunde greșeala?
Pornește acum cu x egal cu 5. Ambele variante aleg ramura if, iar la sfârșit vezi tot 5. Un test care pare reușit poate ascunde atribuirea greșită. Tabelul arată ce se întâmplă pentru trei valori inițiale; fiecare variantă pornește separat de la valoarea din prima coloană:
| x la început | După if (x = 5) | După if (x == 5) |
|---|---|---|
| 7 | ramura if; x devine 5 | ramura else; x rămâne 7 |
| 5 | ramura if; x este 5 | ramura if; x rămâne 5 |
| 0 | ramura if; x devine 5 | ramura else; x rămâne 0 |
De aceea, testează și cu o valoare diferită de cea cu care compari. Afișează x după instrucțiune: poți depista o atribuire chiar când ambele variante aleg aceeași ramură.
Un singur egal face condiția mereu adevărată?
Nu. Înlocuiește condiția din primul program cu if (x = 0). Atribuirea pune zero în x. De data aceasta condiția este falsă: pe ecran apar ramura else și x = 0.
Ca să verifici dacă x este deja zero, scrie if (x == 0). Cu x inițial 7, vei intra tot pe else, dar x va rămâne 7.
Poți corecta rândul înainte să rulezi?
Un exercițiu îți cere să afișezi zero numai dacă x este zero. În cod apare însă:
if (x = 0) {
std::cout << "zero\n";
}
Rescrie condiția și notează ce se afișează pentru x inițial 0, apoi pentru x inițial 7. Lasă răspunsul de mai jos deoparte până termini, ca la verificarea unei lecții fără caiet.
Condiția corectă este if (x == 0). Pentru x inițial 0, apare mesajul zero; pentru x inițial 7, nu apare nimic. x își păstrează valoarea în ambele cazuri. În codul greșit, x = 0 nu lasă mesajul să apară și îl aduce pe x la zero, de oriunde ar fi pornit.