Operatorii în C/C++

Operatorii formează expresii aritmetice, relaționale și logice. Pentru operanzi întregi, 7 / 2 are valoarea 3, iar 7 % 2 are valoarea 1. Comparația se scrie ==, în timp ce = atribuie. && înseamnă „și”, || înseamnă „sau”, iar ! neagă o condiție.

În Python, 7 // 2 dă câtul întreg 3, iar 7 % 2 dă restul 1; în C++ cu operanzi întregi, 7 / 2 dă 3.

Operatorii se grupează în aritmetici (+, -, *, /, %), relaționali (<, <=, >, >=, ==, !=), logici (&&, ||, !), de atribuire (=, +=, -=, *=, /=, %=) și de incrementare (++, --). Tipurile operanzilor decid rezultatul: între doi întregi, / dă câtul împărțirii întregi și % dă restul; dacă măcar un operand este real, / dă rezultatul real. La operanzi negativi câtul se trunchiază spre zero, iar restul are semnul deîmpărțitului: -7 / 2 este $-3$ și -7 % 2 este $-1$, în timp ce 7 / -2 este $-3$ și 7 % -2 este $1$. Valoarea unei comparații sau a unei expresii logice este 1 (adevărat) sau 0 (fals).

Prioritatea operatorilor, de la cea mai mare la cea mai mică, este: ! și ++/-- unari; *, /, %; +, -; <, <=, >, >=; ==, !=; &&; ||; atribuirile. La priorități egale se evaluează de la stânga la dreapta (atribuirea de la dreapta la stânga). Parantezele schimbă ordinea și fac intenția clară. Operatorii && și || se evaluează prin scurtcircuitare: al doilea operand nu se mai evaluează dacă primul decide rezultatul.

Exemplul 1 — aritmetică și condiție logică.

#include <iostream>
using namespace std;
int main() {
    int a = 7, b = 2;
    cout << a / b << " " << a % b << " " << (a > 5 && b < 3);
    return 0;
}

Se afișează 3 1 1: prima expresie este câtul, a doua restul, iar a treia este adevărată, reprezentată prin 1. Pentru un rezultat real se convertește un operand: double(a) / b dă 3,5.

Exemplul 2 — incrementarea prefixată și postfixată. Forma ++i crește variabila și întoarce valoarea nouă, iar i++ întoarce valoarea veche și abia apoi crește variabila. Pornind de la i = 3:

int i = 3;
int j = i++;
int k = ++i;
cout << i << j << k;

După j = i++ avem $j=3$ și $i=4$; după k = ++i avem $i=5$ și $k=5$. Se afișează 535. Evită să modifici aceeași variabilă de mai multe ori într-o expresie, pentru că rezultatul devine greu de urmărit și, în unele cazuri, nedefinit.

Exemplul 3 — scurtcircuitarea. Expresia a != 0 && 10 / a > 1 este sigură pentru $a=0$: prima parte este falsă, deci 10 / a nu se mai evaluează și rezultatul este 0. Invers, a == 0 || 10 / a > 1 are valoarea 1 pentru $a=0$, tot fără împărțire. Condiția ternară c ? x : y alege x dacă c este adevărată și y altfel: (5 > 3) ? 10 : 20 are valoarea 10. Pentru 3 + 4 * 2 > 10 && !(5 % 2), produsul este 8, suma 11, comparația este adevărată, dar 5 % 2 este 1 și !(1) este fals, deci întreaga expresie are valoarea 0.

Exemplul 4 — folosirea restului. Operatorul % rezolvă trei situații frecvente. Divizibilitatea: n % 3 == 0 este adevărată pentru 18 și falsă pentru 19. Ultima cifră: 25 % 10 este 5. Valorile circulare: dacă este ora 22 și trec 5 ore, ora afișată de ceas este (22 + 5) % 24, adică 3. Atenție la precedență: în a + b % c restul se calculează înaintea adunării, deci 7 + 9 % 4 este $7+1=8$.

Exemplul 5 — atribuirile compuse și ordinea conversiilor. Atribuirea x *= 2 + 1 înseamnă x = x * (2 + 1), deoarece partea din dreapta se evaluează întâi. Pornind de la x = 4: după x += 3 avem 7, după x *= 2 + 1 avem 21, iar după x %= 5 avem 1. Ordinea contează și la tipuri: 5 / 2 * 2.0 este 4,0, pentru că 5 / 2 este împărțire întreagă și dă 2, iar 2.0 * 5 / 2 este 5,0, pentru că primul produs este real. Operatorul % se aplică numai operanzilor întregi: 7.5 % 2 nu se compilează. Împărțirea întreagă la 0, de exemplu 7 / 0, produce eroare la execuție, deci un divizor care poate fi 0 se verifică înainte.

Construiește pașii evaluării pe subexpresii, în ordinea priorităților, și scrie valoarea fiecăreia. Nu interpreta a < b < c ca în matematică: comparația a < b dă 0 sau 1, iar rezultatul se compară apoi cu c; pentru intervale scrie a < b && b < c. Confuzia dintre = și == apare des în if: if (x = 5) atribuie. Reține diferența dintre ++i și i++ când valoarea expresiei este folosită într-o atribuire. Operatorul ! are prioritate mai mare decât ==: !x == y înseamnă (!x) == y, nu negația egalității. Pentru o comparație între numere negative împărțite, aplică regula trunchierii spre zero: -7 / 2 este $-3$, nu $-4$.

Testează întotdeauna cazul limită al unei expresii: pentru x = 17, expresia x / 5 * 5 + x % 5 dă $3\cdot 5+2=17$, adică valoarea lui x, pentru orice întreg pozitiv; dacă lipsește restul, rezultatul 15 arată cât s-a pierdut prin împărțirea întreagă.

Exemplu în formatul examenului. Ce se afișează în urma executării secvenței de mai jos?

int a = 3;
int b = a++;
int c = ++a;
cout << a << b << c;

• a) 333
• b) 345
• c) 535
• d) 544

Răspunsul corect este c). Instrucțiunea b = a++ atribuie lui b vechea valoare a lui a, adică 3, și apoi crește a la 4. Instrucțiunea c = ++a crește întâi a la 5 și atribuie lui c valoarea nouă, 5. Se afișează a, b, c, adică 535. Varianta d) ar rezulta dacă b = a++ ar întoarce valoarea nouă, 4, iar varianta a) dacă nicio variabilă nu s-ar modifica.

Al doilea exemplu rezolvat — scurtcircuitarea. Se execută int a = 4, b = 0; cout << (b != 0 && a / b > 1) << (b == 0 || a / b > 1);. În prima paranteză b != 0 este fals, deci a / b nu se evaluează și rezultatul este 0. În a doua, b == 0 este adevărat, deci nici aici nu se împarte la zero, iar rezultatul este 1. Se afișează 01. Fără scurtcircuitare, aceleași expresii ar fi cerut o împărțire la 0.

Greșeli frecvente

• Greșit: = și == au același rol în C++.
  Corect: primul atribuie, al doilea compară egalitatea.
• Greșit: a < b < c verifică dacă $b$ este între $a$ și $c$.
  Corect: se compară rezultatul 0 sau 1 al lui a < b cu c; condiția corectă este a < b && b < c.
• Greșit: b = a++ și b = ++a dau aceeași valoare lui b.
  Corect: prima atribuie vechea valoare a lui a, a doua valoarea mărită.

Înainte și după