De ce contează?
Tabla din clasă e vizibilă tuturor: oricine se ridică poate scrie sau șterge pe ea, și toți văd ce e scris. E comodă pentru ce e comun tuturor — dar dacă cineva șterge ceva ce-ți trebuia, e greu de aflat cine a fost. Variabila globală e tabla programului tău.
Ce este o variabilă globală?
O variabilă globală este declarată în afara oricărei funcții, de obicei sus, după #include-uri. E vizibilă din toate funcțiile care vin după declararea ei.
#include <iostream>
using namespace std;
int n; // globala: vizibila peste tot
int v[1000]; // si vectorul e global
int main() {
// n si v sunt accesibile aici
}Globalele se inițializează automat cu zero: un int global pornește de la 0, un vector global e plin cu 0. Localele, în schimb, pornesc cu valori de gunoi dacă nu le inițializezi.
Când sunt utile
În problemele de concurs, vectorii mari și valorile partajate de mai multe funcții se declară deseori global, din două motive practice:
- Acces ușor: nu trebuie să le pasezi prin parametri la fiecare funcție.
- Memorie: vectorii globali stau într-o zonă de memorie mare; un
int v[1000000]local înmainpoate depăși stiva și produce crash, dar global e în siguranță.
#include <iostream>
using namespace std;
int n;
int v[100005]; // vector mare, declarat global
int suma() {
int s = 0; // s e local
for (int i = 0; i < n; i++) s += v[i]; // n si v sunt globale
return s;
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) cin >> v[i];
cout << suma() << "\n";
return 0;
}Funcția suma folosește n și v direct, fără să le primească prin parametri — pentru că sunt globale.
Locală vs. globală — cine câștigă la nume identic?
Dacă o funcție are o variabilă locală cu același nume ca o globală, localul are prioritate în acea funcție:
#include <iostream>
using namespace std;
int x = 100; // global
void f() {
int x = 5; // local, "umbreste" globalul
cout << x << "\n"; // 5 (cel local)
}
int main() {
f();
cout << x << "\n"; // 100 (globalul, neatins)
return 0;
}În f, numele x se referă la cel local. Globalul x rămâne 100.
De ce le folosim cu măsură
Comoditatea globalelor are un preț: orice funcție le poate modifica. Într-un program mare, dacă o globală are o valoare greșită, trebuie să verifici toate funcțiile ca să afli cine a stricat-o. Variabilele locale + parametrii fac fluxul de date explicit și mai ușor de depanat.
Regula practică pentru concurs: vectori mari și n-ul de intrare — global e ok. Variabile de lucru temporare (i, s, temp) — păstrează-le locale.
Capcane cu variabile globale:
- Te bazezi că o globală e „proaspătă" la fiecare apel: nu e — păstrează ce a lăsat apelul anterior. Resetează-o explicit dacă ai nevoie.
- Uiți că un local umbrește globalul: declari din greșeală
int nlocal și te miri că modificările nu se văd în afară. - Vector mare declarat local în
main:int v[1000000]înmainpoate da stack overflow. Declară-l global. - Mai multe funcții scriu în aceeași globală fără să-ți dai seama: bug greu de găsit. Limitează scrierile.
Recapitulare
- O variabilă globală e declarată în afara funcțiilor și e vizibilă din toate funcțiile de după ea.
- Globalele pornesc automat de la zero; sunt utile pentru vectori mari și valori partajate.
- Un nume local umbrește globalul cu același nume; folosește globalele cu măsură, fiindcă orice funcție le poate schimba.