Expresii și operatori

O expresie combină valori și operații pentru a obține un rezultat. Expresia $3+4$ are rezultatul 7. Semnele „+” și „−” sunt operatori aritmetici. Înmulțirea și împărțirea sunt tot operații aritmetice. Parantezele arată ce calculezi mai întâi: $2\cdot (3+4)=14$, pe când $2\cdot 3+4=10$.

Unele expresii nu dau un număr, ci un răspuns de tip adevărat sau fals. „7 este mai mare decât 5” este adevărat; „7 este egal cu 5” este fals. Semnele „>”, „<” și „=” folosite în comparații se numesc operatori relaționali. Într-un algoritm, rezultatul comparației poate hotărî ce pas urmează.

Poți lega două condiții prin „și” sau „sau”. „Numărul este mai mare decât 5 și mai mic decât 10” este adevărat pentru 7. Pentru 12, prima parte este adevărată, dar a doua este falsă, deci condiția cu „și” este falsă. La „sau” ajunge ca una dintre părți să fie adevărată. Cuvântul „nu” inversează răspunsul unei condiții.

Încearcă să calculezi expresiile pas cu pas, nu dintr-o privire. Pentru $n=7$, întâi verifici $7>5$ (adevărat), apoi $7<10$ (adevărat), iar la final unești rezultatele prin „și” (adevărat). Dacă adaugi paranteze, ele pot schimba ordinea sau gruparea operațiilor. O urmă scrisă te ajută să vezi exact de unde vine răspunsul.

Exemplu rezolvat — o expresie și o condiție, pas cu pas. Se dă numărul $n=7$. Calculezi expresia $2\cdot (n+3)-4$ și apoi verifici dacă rezultatul este mai mare decât 10 și par.

1. Înlocuiești $n$ cu 7: $2\cdot (7+3)-4$.
2. Parantezele se calculează primele: $7+3=10$.
3. Urmează înmulțirea: $2\cdot 10=20$.
4. La sfârșit scazi: $20-4=16$.
5. Verifici condiția: „16 este mai mare decât 10” este adevărat, „16 este par” este adevărat. Două afirmații adevărate legate prin „și” dau un rezultat adevărat.

Pentru comparații se folosesc semnele $<$, $>$, $\le$, $\ge$, $=$ și $\ne$, iar rezultatul este întotdeauna „adevărat” sau „fals”. Dacă n ar fi 3, ai obține $2\cdot 6-4=8$; „8 este mai mare decât 10” este fals, deci întreaga condiție este falsă, chiar dacă 8 este par.

O expresie este formată din operanzi (valori, variabile) și operatori. Operatorii aritmetici sunt +, -, *, / și %. Între doi întregi, / dă câtul împărțirii întregi, iar % dă restul: 7 / 2 este 3, iar 7 % 2 este 1. Dacă măcar un operand este real, / dă rezultatul real: 7 / 2.0 este 3,5. Operatorii relaționali <, <=, >, >=, ==, != compară două valori și dau rezultat logic. Operatorii logici && (și), || (sau) și ! (nu) combină condiții. În C++ valoarea logică „adevărat” se afișează 1, iar „fals” se afișează 0.

Prioritatea operatorilor, de la cea mai mare: !, apoi *, /, %, apoi +, -, apoi <, <=, >, >=, apoi ==, !=, apoi &&, apoi ||; atribuirea are cea mai mică prioritate. La priorități egale se evaluează de la stânga la dreapta. Parantezele pot schimba ordinea și fac expresia mai ușor de citit. Operatorul && evaluează al doilea operand numai dacă primul este adevărat, iar || numai dacă primul este fals.

Exemplul 1 — expresie aritmetică. Pentru $a=17$ și $b=5$ se calculează a / b (câtul 3), a % b (restul 2), (a + b) * 2 - a % b și a / (double)b.

#include <iostream>
using namespace std;
int main() {
    int a = 17, b = 5;
    cout << a / b << ' ' << a % b << ' ' << (a + b) * 2 - a % b << ' ' << a / (double)b;
    return 0;
}

Programul afișează 3 2 42 3.4. A treia valoare se obține astfel: $(17+5)\cdot 2=44$ și $44-2=42$; restul $17\mathrm{mod}5$ se calculează înaintea scăderii, pentru că % are prioritate mai mare decât -.

Exemplul 2 — an bisect. Un an este bisect dacă se împarte exact la 4 și nu se împarte la 100, sau dacă se împarte exact la 400. Condiția se scrie (an % 4 == 0 && an % 100 != 0) || an % 400 == 0.

#include <iostream>
using namespace std;
int main() {
    int ani[] = {1900, 2000, 2024};
    for (int an : ani)
        cout << ((an % 4 == 0 && an % 100 != 0) || an % 400 == 0) << ' ';
    return 0;
}

Programul afișează 0 1 1. Pentru 1900: $1900\mathrm{mod}4=0$, dar $1900\mathrm{mod}100=0$, deci prima parte este falsă, iar $1900\mathrm{mod}400=300$, deci și a doua parte este falsă. Pentru 2000: prima parte este falsă din cauza lui 100, dar $2000\mathrm{mod}400=0$, deci condiția este adevărată. Pentru 2024: $2024\mathrm{mod}4=0$ și $2024\mathrm{mod}100=24$, deci prima parte este adevărată.

Exemplul 3 — condiții compuse pe un interval. Numărul $n$ are două cifre dacă $10\le n\le 99$. Condiția se scrie cu &&, nu într-o singură comparație înlănțuită: n >= 10 && n <= 99. Pentru valorile 7, 10, 99 și 100 expresia dă 0, 1, 1 și 0, deoarece 7 este prea mic, 10 și 99 sunt la limite și intră, iar 100 depășește limita de sus. Evaluarea parțială protejează și împotriva erorilor: în b != 0 && a / b > 1 cu $b=0$ prima parte este falsă, deci împărțirea nu se mai execută, iar expresia dă 0. Scrisă invers, a / b > 1 && b != 0, ar cere o împărțire la zero.

Exemplul 4 — evaluarea pas cu pas și comparația înlănțuită. Pentru $a=9$ și $b=7$ se evaluează a + b % 3 * 2 > 10 - a / 4 && !(b == 0). Prima dată se calculează b % 3 (restul 1), apoi 1 * 2 (2) și a + 2 (11). În partea dreaptă, a / 4 este 2 (cât întreg), iar 10 - 2 este 8. Comparația 11 > 8 dă 1. Apoi b == 0 dă 0, iar ! îl transformă în 1. Rezultatul final este 1 && 1, deci 1.

O greșeală tipică de scriere este 1 < x && x < 5 înlocuit cu 1 < x < 5. Pentru $x=9$, întâi se calculează 1 < 9, adică 1, apoi 1 < 5, adică tot 1: expresia dă 1, deși 9 nu este între 1 și 5.

La o expresie mixtă, stabilește tipurile operanzilor înainte de calcul. Pentru întregi, 7 / 2 dă 3, iar 7 % 2 dă 1. Condiția (7 / 2 == 3) && (7 % 2 == 1) este adevărată. O comparație între numere reale se face pe valorile exacte, iar rezultatul unei comparații este 0 sau 1 și poate intra într-un calcul aritmetic. Nu confunda = cu ==: în if (x = 5) se atribuie, nu se compară, iar valoarea 5 este considerată adevărată. Într-un fragment de examen, scrie valoarea fiecărei subexpresii în ordinea în care se evaluează; erorile apar de obicei la priorități (% înaintea lui +) și la împărțirea întreagă.

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

int a = 7, b = 2;
cout << a / b + a % b * 2 << ' ' << (a > b && b != 0);

• a) 3 1
• b) 5 1
• c) 8 1
• d) 5 0

Răspunsul corect este b). Înmulțirea și împărțirea au prioritate față de adunare, iar /, %, * se evaluează de la stânga la dreapta: a / b este 3, a % b este 1, iar 1 * 2 este 2. Suma este $3+2=5$. Condiția a > b && b != 0 este adevărată, deci se afișează 1. Varianta c) rezultă dacă se adună întâi $3+1$ și se înmulțește cu 2, iar varianta a) ignoră înmulțirea cu 2.

Al doilea exemplu: valori logice în calcul. Ce se afișează pentru x = 12?

int x = 12;
cout << (x % 5 == 2 || x / 5 == 3) << ' ' << (x > 10 && x % 3) << ' ' << x / 5 * 5 + x % 5;

Prima expresie: x % 5 este 2, deci x % 5 == 2 este adevărat, iar || nu mai evaluează a doua parte; se afișează 1. A doua: x > 10 este adevărat, dar x % 3 este 0, adică fals, deci && dă 0. A treia: x / 5 este 2, 2 * 5 este 10, x % 5 este 2, iar suma este 12, adică exact $x$. Se afișează 1 0 12.

Greșeli frecvente

• Greșit: = și == au același rol în C++.
  Corect: primul atribuie, al doilea compară egalitatea.
• Greșit: 7 / 2 produce 3.5 când ambii operanzi sunt întregi.
  Corect: rezultatul este câtul întreg 3.
• Greșit: la o condiție cu „și” ajunge ca o parte să fie adevărată.
  Corect: ambele părți trebuie să fie adevărate.

Înainte și după