Constante și variabile

O variabilă este un nume sub care păstrezi o valoare ce se poate schimba în timpul algoritmului. Imaginează-ți o cutie cu eticheta „scor”. La început pui în ea 0. După primul răspuns bun, înlocuiești valoarea cu 1. După al doilea, cu 2. Eticheta rămâne, iar conținutul se schimbă.

O constantă este o valoare pe care algoritmul o folosește fără să o modifice. Într-un joc în care fiecare răspuns bun aduce mereu 5 puncte, numărul 5 poate fi o constantă. Scorul total este o variabilă, fiindcă trece de la 0 la 5, apoi la 10. Dacă ai pornit cu 0 puncte și ai două răspunsuri bune, poți urmări pașii: $0+5=5$, apoi $5+5=10$; scorul final este 10 puncte.

Într-o schemă simplă poți scrie „scor primește scor + 5”. Asta înseamnă: citești valoarea veche, aduni 5 și păstrezi valoarea nouă sub același nume. Nu este o egalitate matematică precum $x=x+5$; este o instrucțiune de schimbare a stării.

Numele variabilelor ar trebui să te ajute să înțelegi ce păstrează: „scor”, „total” sau „număr de pași” spun mai mult decât o literă aleasă întâmplător. Ca să verifici algoritmul, notează valoarea fiecărei variabile după fiecare schimbare. Astfel observi imediat dacă ai uitat să o inițializezi.

Exemplu rezolvat — economiile lui Matei. Matei are 20 de lei în pușculiță. Îi mai dă bunica 15 lei, apoi cumpără un caiet de 10 lei. Câți lei are la final? Numești „economii” variabila care păstrează suma, iar valorile 15 și 10 sunt numere date în problemă.

1. La început, economii primește 20.
2. Matei primește 15 lei: economii primește economii + 15, adică $20+15=35$.
3. Matei cumpără caietul: economii primește economii − 10, adică $35-10=25$.

La final, în variabila „economii” rămâne valoarea 25. Numele rămâne același, dar valoarea s-a schimbat de două ori. Pentru a nu greși, scrie după fiecare pas valoarea nouă: 20, 35, 25.

O variabilă are un nume, un tip și o valoare care se poate schimba pe parcursul execuției; o constantă are o valoare fixată, care nu se mai modifică. În C++, declarația int scor = 0; creează variabila scor de tip întreg și îi dă valoarea inițială 0. Declarația const int punctePeRaspuns = 5; creează o constantă: încercarea de a-i atribui o altă valoare ulterior este eroare de compilare. Constantele numite evită „numerele magice” din cod și permit modificarea unei valori într-un singur loc.

Atribuirea x = x + 5 nu este o egalitate matematică: partea dreaptă se evaluează cu valoarea veche a lui x, iar rezultatul se păstrează în x. Operatorii compuși +=, -=, *= fac aceeași operație mai scurt: x += 5 este echivalentă cu x = x + 5. O variabilă locală de tip int fără valoare inițială conține o valoare nedeterminată, deci citirea ei înainte de prima atribuire este o greșeală.

Exemplul 1 — scorul unui joc. Fiecare răspuns bun aduce mereu 5 puncte, deci numărul 5 este constantă. Scorul se schimbă, deci este variabilă.

#include <iostream>
using namespace std;
int main() {
    const int punctePeRaspuns = 5;
    int scor = 0;
    scor = scor + punctePeRaspuns;
    scor = scor + punctePeRaspuns;
    cout << scor;
    return 0;
}

Stările succesive sunt scor = 0, scor = 5, scor = 10; se afișează 10. Inițializarea lui scor cu 0 este necesară înainte ca valoarea lui veche să intre într-un calcul.

Exemplul 2 — aria unui cerc. Numărul $\pi$ nu se schimbă niciodată, deci se declară ca o constantă numită; raza este variabilă. Aria este $\pi r^2$, iar pentru raza 2 se obține $3,14159\cdot 4=12,56636$.

#include <iostream>
using namespace std;
int main() {
    const double PI = 3.14159;
    double raza = 2;
    double aria = PI * raza * raza;
    cout << aria;
    return 0;
}

Programul afișează 12.5664: fluxul de ieșire arată implicit șase cifre semnificative, deci valoarea 12,56636 apare rotunjită. Dacă valoarea lui $\pi$ este folosită în zece locuri, o schimbi o singură dată, la declarația constantei.

Exemplul 3 — interschimbarea a două variabile. Pentru a schimba valorile lui a și b este nevoie de o a treia variabilă, în care se păstrează temporar prima valoare:

int a = 3, b = 8, aux;
aux = a;
a = b;
b = aux;
cout << a << ' ' << b;

Stările sunt: după aux = a, aux este 3; după a = b, a este 8; după b = aux, b este 3. Se afișează 8 3. Fără aux, secvența a = b; b = a; distruge prima valoare: după prima instrucțiune a este 8 și valoarea 3 s-a pierdut, deci a doua instrucțiune lasă ambele variabile egale cu 8 și se afișează 8 8. Ordinea atribuirilor contează: fiecare atribuire folosește valorile pe care variabilele le au în acel moment, nu pe cele de la începutul programului. Același schimb din trei atribuiri apare în sortări, la fiecare pereche de elemente aflate în ordine greșită.

Incrementarea și decrementarea. Pentru modificarea cu 1 se folosesc k++ și k--. Dacă k = 4, după k++ valoarea este 5; după k-- și încă un --k ajunge la 3. Forma y = x++ atribuie întâi vechea valoare: pentru x = 7 rezultă y = 7 și x = 8. Folosește această formă cu grijă, pentru că ordinea evenimentelor devine greu de urmărit.

Ce nu poate face o constantă. După declarația const int limita = 10;, instrucțiunea limita = 11; nu compilează. O variabilă poate primi o valoare nouă oricând, dar tipul ei nu se schimbă: o variabilă int nu păstrează partea zecimală.

La urmărirea codului, actualizează variabila după evaluarea părții drepte. Dacă x = 2, instrucțiunea x = x + 3 produce x = 5; aplicată încă o dată, produce x = 8. Instrucțiunile compuse se desfac în același fel: x *= 2 înseamnă x = x * 2. Distinge o egalitate matematică de o atribuire: x = x + 1 este corectă într-un program și imposibilă într-o ecuație. Într-un tabel de urmărire se scrie un rând pentru fiecare instrucțiune și valoarea variabilei după ea; la constante nu apar rânduri noi, pentru că valoarea lor nu se schimbă. Două capcane apar des în fragmente: o variabilă folosită în calcul fără valoare inițială (rezultatul nu poate fi dedus din cod) și o constantă căreia i se atribuie o valoare (secvența nu compilează, deci nu afișează nimic). Dacă întrebarea cere valoarea finală, calculează întâi pe hârtie fiecare pas, apoi compară rezultatul cu variantele.

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

int x = 2;
x += 3;
x *= 2;
x -= 1;
cout << x;

• a) 9
• b) 8
• c) 10
• d) 5

Răspunsul corect este a). După x += 3 avem $x=5$. După x *= 2 avem $x=10$. După x -= 1 avem $x=9$. Varianta c) ignoră ultima instrucțiune, varianta d) se oprește după prima, iar varianta b) rezultă dacă ordinea ultimelor două instrucțiuni este inversată: $(5-1)\cdot 2=8$.

Al doilea exemplu — schimb fără variabilă ajutătoare. Ce se afișează în urma executării secvenței de mai jos?

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

După prima instrucțiune $a=5$, după a doua $b=5+2=7$, iar după a treia $a=7-5=2$. Se afișează 2 7: valorile au fost interschimbate.

Greșeli frecvente

• Greșit: x = x + 1 este imposibil fiindcă $x\ne x+1$.
  Corect: în program, partea dreaptă se evaluează cu valoarea veche, apoi se atribuie valoarea nouă.
• Greșit: o variabilă întreagă declarată, dar neinițializată local, începe sigur de la zero.
  Corect: trebuie inițializată înainte de folosirea valorii ei.
• Greșit: const înseamnă că valoarea poate fi schimbată mai târziu.
  Corect: o constantă declarată cu const nu poate primi o nouă valoare.

Înainte și după