Declarații și constante

O declarație precizează numele și tipul unei variabile înainte de folosire. În C++, int numar = 4; declară un întreg și îi dă valoarea inițială 4. O constantă numită, de exemplu const int limita = 10;, nu poate fi modificată ulterior în program. Numele clare ajută la citirea algoritmului.

O declarație introduce un nume și îi asociază un tip. În C++, int numar; declară variabila numar; int numar = 4; o declară și o inițializează cu valoarea 4 (declarare cu inițializare). Mai multe variabile de același tip se pot declara împreună, int a = 1, b = 2;. O constantă se declară cu const, const int limita = 10;, trebuie inițializată la declarare și nu mai poate fi modificată. Tipul rămâne important: const double PI = 3.14159; memorează un real, iar încercarea de a-i atribui o valoare nouă este eroare de compilare.

O variabilă locală de tip numeric, neinițializată, are o valoare nedeterminată, deci citirea ei înainte de atribuire nu are rezultat sigur. O variabilă globală, declarată în afara oricărei funcții, este inițializată implicit cu 0. Declarațiile pot fi locale unui bloc: o variabilă declarată între acolade este vizibilă numai în acel bloc, de la declarație până la acolada de închidere. Dacă un bloc interior declară un nume deja folosit în blocul exterior, numele interior îl ascunde pe cel exterior cât timp blocul interior este activ.

Exemplul 1 — constantă și variabilă.

#include <iostream>
using namespace std;
int main() {
    const int prag = 10;
    int x = 7;
    int diferenta = prag - x;
    cout << diferenta;
    return 0;
}

Programul afișează 3. Nici prag, nici x nu sunt modificate de expresia din inițializarea lui diferenta, deoarece partea dreaptă doar citește valorile.

Exemplul 2 — blocuri și nume ascunse. În fragmentul următor numele x este declarat de două ori:

int x = 1;
{
    int x = 2;
    cout << x;
}
cout << x;

În blocul interior x este variabila nouă, cu valoarea 2, deci prima afișare dă 2. După acolada de închidere, variabila interioară nu mai există și x desemnează iar variabila exterioară, cu valoarea 1. Se afișează 21. Variabila exterioară nu a fost modificată, pentru că cea interioară este o altă variabilă.

Declarația nu este același lucru cu atribuirea. int x; rezervă spațiu pentru x, x = 5; îi dă o valoare, iar int x = 5; face ambele într-o singură instrucțiune. Un nume se poate declara o singură dată în același bloc: două declarații int x; una după alta, în același bloc, sunt eroare.

Exemplul 3 — valori implicite. Dacă declari int g; în afara funcției main, g este 0; dacă declari int l = 5; în interiorul ei, l este 5. Afișarea lor, în ordinea g, l, dă 05. Cu ajutorul unei constante poți fixa și dimensiunea unui tablou: const int N = 5; int a[N]; declară un tablou cu cinci elemente numerotate de la 0 la 4, iar dacă dimensiunea se schimbă, modifici o singură valoare.

Exemplul 4 — variabila declarată în for. În for (int i = 1; i <= 3; i++) cout << i; variabila i există numai cât timp se execută instrucțiunea for. Se afișează 123, iar o instrucțiune cout << i; scrisă după ciclu este eroare de compilare, pentru că i nu mai este vizibil. Dacă ai nevoie de valoarea lui i după ciclu, declari int i; înaintea lui și scrii for (i = 1; i <= 3; i++); după ciclu, i are valoarea 4.

Alegerea tipului. int memorează întregi între $-2147483648$ și $2147483647$, long long întregi mult mai mari, double numere reale, char un caracter, iar bool valorile true și false. Dacă adunăm două numere de ordinul $2\cdot 10^9$, suma depășește limita lui int, deci rezultatul se declară long long.

La urmărirea unui fragment, separă declararea, inițializarea și atribuirea ulterioară. int a = 2; a = 5; lasă în a valoarea 5. O atribuire către un obiect declarat const este invalidă, deci secvența care o conține nu compilează și nu afișează nimic. Când apare un bloc interior cu un nume deja folosit, stabilește la care declarație se referă fiecare apariție înainte de a calcula expresiile: o apariție se referă la cea mai apropiată declarație vizibilă din blocurile care o conțin. Folosirea unui nume înainte de declarația lui sau după ce blocul care îl conține s-a încheiat este eroare de compilare, deci un fragment de acest fel nu afișează nimic. Același lucru e valabil pentru variabila declarată în antetul unui for: ea nu mai există după ciclu. Verifică și tipul declarat: după int a = 7 / 2; valoarea lui a este 3, iar după double b = 7 / 2; valoarea lui b este tot 3, nu 3,5.

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

int x = 4;
{
    int x = 7;
    x = x + 1;
}
x = x + 2;
cout << x;

• a) 6
• b) 8
• c) 10
• d) 14

Răspunsul corect este a). În blocul interior, x este o variabilă nouă: ea pornește de la 7 și ajunge la 8, dar dispare la sfârșitul blocului. Variabila exterioară a rămas 4. Atribuirea x = x + 2 o modifică pe cea exterioară: $4+2=6$. Varianta b) afișează valoarea variabilei interioare, iar varianta c) presupune că ambele nume sunt aceeași variabilă: $8+2=10$.

Greșeli frecvente

• Greșit: o variabilă locală de tip numeric declarată fără valoare începe cu 0.
  Corect: valoarea ei este nedeterminată până la prima atribuire.
• Greșit: un bloc interior care declară x modifică și x din blocul exterior.
  Corect: declarația interioară creează o variabilă nouă care ascunde pe cea exterioară.
• Greșit: o constantă declarată cu const poate primi altă valoare mai târziu.
  Corect: o atribuire către ea este eroare de compilare.

Înainte și după