Atribuirea

Atribuirea pune o valoare nouă într-o variabilă. Într-un algoritm, poți spune „scor primește 5”. De atunci, scorul are valoarea 5, până când o altă instrucțiune îl schimbă. Nu este o afirmație că două lucruri sunt egale pentru totdeauna; este un pas care modifică starea algoritmului.

Partea din dreapta se calculează înainte de schimbarea variabilei din stânga. Dacă scorul este 5 și execuți „scor primește scor + 2”, întâi faci $5+2=7$, apoi păstrezi 7 sub numele „scor”. Dacă repeți pasul, pornești de la 7 și obții 9. Urmărirea este: 5, apoi 7, apoi 9.

Poți folosi și altă variabilă. Ai două borcane cu câte 3 și 4 bile, notate $a$ și $b$. Dacă scrii „$a$ primește $a+b$”, $a$ devine 7, dar $b$ rămâne 4. Dacă vrei să păstrezi valoarea inițială a lui $a$, trebuie să o copiezi mai întâi într-o a treia variabilă. Altfel, noua valoare o înlocuiește pe cea veche.

Ordinea atribuirilor poate schimba rezultatul. „$a$ primește $b$”, apoi „$b$ primește $a$” nu schimbă între ele valorile inițiale: după prima instrucțiune, ambele au deja valoarea veche a lui $b$. Un tabel cu valorile de după fiecare pas te ajută să vezi exact ce s-a pierdut. Înainte de a citi valoarea unei variabile, verifică dacă i-ai dat una.

Exemplu rezolvat — urmărirea a trei atribuiri. Se dau instrucțiunile „$x$ primește 2”, „$y$ primește $x+1$” și „$x$ primește $y+1$”. Care sunt valorile finale?

1. După prima instrucțiune: $x=2$.
2. A doua instrucțiune calculează partea dreaptă, $x+1=3$, și o păstrează în $y$: $y=3$, iar $x$ rămâne 2.
3. A treia instrucțiune calculează $y+1=4$ și o păstrează în $x$: $x=4$, iar $y$ rămâne 3.

Valorile finale sunt $x=4$ și $y=3$. Observă că $y$ nu s-a modificat când s-a schimbat $x$: a fost calculat o singură dată, cu valoarea pe care o avea $x$ în acel moment. Instrucțiunea „$y$ primește $x+1$” nu leagă pe $y$ de $x$ pentru tot restul programului.

Atribuirea are forma variabila = expresie;. Se evaluează expresia din dreapta cu valorile curente ale variabilelor, rezultatul este convertit la tipul variabilei din stânga (dacă conversia este permisă), apoi se memorează în variabilă. Valoarea veche a variabilei din stânga se pierde. Operatorul = atribuie, iar == compară. Atribuirea poate fi înlănțuită: p = q = 5; dă lui q valoarea 5, apoi lui p valoarea lui q. Operatorii compuși +=, -=, *=, /=, %= combină o operație cu atribuirea: x += 3 înseamnă x = x + 3.

Exemplul 1 — interschimbarea cu variabilă temporară.

#include <iostream>
using namespace std;
int main() {
    int a = 3, b = 4;
    int temporar = a;
    a = b;
    b = temporar;
    cout << a << " " << b;
    return 0;
}

După temporar = a avem $(a;b;\text{temporar})=(3;4;3)$; după a = b avem $(4;4;3)$; după b = temporar obținem $(4;3;3)$. Ieșirea este 4 3. Variabila temporară păstrează valoarea care altfel s-ar fi pierdut la a doua atribuire.

Exemplul 2 — conversia la atribuire. Tipul variabilei din stânga decide rezultatul: int a = 7 / 2; dă 3, pentru că împărțirea de întregi este întreagă. double b = 7 / 2; dă tot 3, fiindcă împărțirea se face înainte de conversie. Abia double c = 7 / 2.0; dă 3,5. Atribuirea unui real într-un întreg elimină partea zecimală, fără rotunjire: după int k = 3.9; valoarea lui k este 3.

int a = 7 / 2;
double b = 7 / 2;
double c = 7 / 2.0;
cout << a << ' ' << b << ' ' << c;

Secvența afișează 3 3 3.5.

Exemplul 3 — atribuiri înlănțuite și compuse. După p = q = 5; ambele variabile au valoarea 5. Apoi p += 2; dă $p=7$, iar q *= 3; dă $q=15$. Se afișează 7 15. Fiecare atribuire compusă folosește valoarea variabilei din momentul executării ei, nu valoarea inițială.

Atribuirea ca expresie. În C++ atribuirea are ea însăși o valoare, cea care a fost memorată. De aceea a = (b = 4) + 1; memorează 4 în b, apoi calculează $4+1=5$ și îl memorează în a: după instrucțiune $a=5$ și $b=4$. Această proprietate permite lanțul p = q = 5, dar fragmentele care o folosesc în condiții sunt greu de citit și produc des greșeli.

Exemplul 4 — operatori compuși pe întregi. Împărțirea compusă /= rămâne împărțire întreagă când variabila este de tip int. Pentru int n = 10; secvența n /= 4; n += 1; n *= n; dă pe rând $n=2$ (câtul lui 10 la 4), $n=3$ și $n=9$. Pentru int m = 17; secvența m %= 5; m -= 1; dă $m=2$ (restul lui 17 la 5), apoi $m=1$. Contorizarea se scrie k = k + 1: pornind de la 0 și executată de trei ori, instrucțiunea dă pe rând 1, 2, 3.

Exemplul 5 — interschimbarea fără variabilă temporară. Aceeași operație se poate face cu trei atribuiri aritmetice, dacă suma încape în tipul întreg.

int a = 3, b = 4;
a = a + b;
b = a - b;
a = a - b;
cout << a << ' ' << b;

Perechile $(a;b)$ sunt $(3;4)$, apoi $(7;4)$ după prima atribuire, $(7;3)$ după a doua și $(4;3)$ după a treia. Se afișează 4 3. A doua atribuire folosește noul $a=7$ și vechiul $b=4$, adică $7-4=3$, vechea valoare a lui $a$. Metoda este fragilă: pentru valori apropiate de limita lui int, suma $a+b$ depășește domeniul și rezultatul este greșit, de aceea varianta cu temporar rămâne cea sigură.

Exemplul 6 — atribuirea repetată într-un ciclu. Atribuirea s = s + i * i; din interiorul unui ciclu acumulează sume de pătrate.

int s = 0;
for (int i = 1; i <= 4; i++)
    s = s + i * i;
cout << s;

La fiecare iterație partea dreaptă folosește suma de până atunci: $s$ devine 1, apoi $1+4=5$, apoi $5+9=14$, apoi $14+16=30$. Se afișează 30. Dacă ai scrie s = i * i;, fiecare iterație ar înlocui suma cu un singur pătrat și ai obține $16$.

Atribuire sau comparație. În if (a = 0) se atribuie 0 lui a, iar valoarea expresiei, 0, este tratată ca fals; condiția nu compară nimic și schimbă valoarea lui a. Comparația se scrie a == 0.

Urmărește atribuirile în ordine, inclusiv cele care folosesc aceeași variabilă pe ambele părți. Pentru x=2; y=x+1; x=y+1; rezultă y=3 și x=4. Nu reevalua retroactiv pe y după ce x s-a schimbat. Într-un fragment cu atribuiri compuse, scrie fiecare instrucțiune în forma extinsă (x *= 2 devine x = x * 2) și notează valorile în tabel. Când tipurile diferă, aplică conversia la momentul atribuirii: partea zecimală se pierde la memorarea într-un int. Operatorul %= păstrează restul, iar /= pe întregi păstrează câtul: pornind de la 10, n /= 4 dă 2, nu 2,5. Dacă o instrucțiune din subiect are două atribuiri pe aceeași linie, a = b = 7;, execută-le de la dreapta la stânga și notează valoarea fiecărei variabile după fiecare pas.

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

int x = 2, y;
y = x + 1;
x = y + 1;
y = x * y;
cout << x << ' ' << y;

• a) 4 3
• b) 4 12
• c) 3 12
• d) 12 4

Răspunsul corect este b). După y = x + 1 avem $y=3$. După x = y + 1 avem $x=4$. Ultima atribuire folosește valorile curente, $x=4$ și $y=3$, și dă $y=4\cdot 3=12$, în timp ce $x$ rămâne 4. Se afișează 4 12. Varianta a) uită ultima atribuire, iar varianta d) inversează ordinea afișării.

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

int a = 5, b = 2;
a = a - b;
b = a + b;
a = b - a;
cout << a << ' ' << b;

• a) 5 2
• b) 2 5
• c) 3 5
• d) 2 3

Răspunsul corect este b). După a = a - b avem $a=3$ și $b=2$. După b = a + b avem $b=3+2=5$. După a = b - a avem $a=5-3=2$. Se afișează 2 5. Varianta c) se oprește după a doua atribuire, iar varianta a) arată valorile inițiale, ca și cum nicio atribuire nu ar modifica nimic.

Greșeli frecvente

• Greșit: x = y + 1 leagă permanent pe x de y.
  Corect: instrucțiunea calculează valoarea o singură dată, la executare.
• Greșit: double b = 7 / 2; memorează 3,5.
  Corect: împărțirea întreagă dă 3, iar conversia la real dă 3.
• Greșit: atribuirea schimbă și valoarea din dreapta.
  Corect: se modifică numai variabila din stânga.

Înainte și după