Subprograme

LECȚIA 3 Definirea și declararea unei funcții

Variabile globale, variabile locale

Prof. Daniela Stratulat

 Definirea și declararea unei funcții
Declaraţia conţine antetul funcţiei şi informează compilatorul
asupra tipului, numelui funcţiei şi a listei parametrilor formali (în
care se indică tipul parametrilor formali şi numele acestora).
Declaraţiile de funcţii se mai numesc numesc prototipuri.

tip_returnat nume_funcţie (lista parametri formali);

Definiţia conţine antetul funcţiei şi corpul acesteia. Nu este admisă

definirea unei funcţii în corpul altei funcţii.

tip_returnat nume_funcţie (lista parametrilor formali)

{
instrucţiune compusă;
}
Definire după funcția main(),
caz în care funția e declarată
prin prototipul său.
#include <iostream>
using namespace std;
void mesaj();
Definire înainte de funcția
main(), caz în care declararea
funcției prin prototipul său,
poate lipsi.
#include <iostream>
using namespace std;

int main() void mesaj()

{ mesaj(); { cout<<"Subprogram";
return 0; }
}
int main()
void mesaj() { mesaj();
{ cout<<"Subprogram"; return 0;
} }
Programul următor conţine două funcţii: s1 şi s2. Definiţiile ambelor funcţii
se găsesc înaintea funcţiei main(). Din acest motiv ele pot fi apelate din
main(). Definiţia funcţiei s1 este înaintea definiţiei lui s2, deci funcţia s1
poate fi apelată din s2. În schimb, din s1 nu poate fi apelată funcţia s2.

#include <iostream>
using namespace std;
void s1()
{ cout<<"Eu sunt s1"<<endl;
}
void s2()
{ s1(); cout<<"Eu sunt s2"<<endl;
}
int main()
{ s1();
s2();
return 0;
}
Programatorii în C++ obişnuiesc să scrie mai întâi prototipurile tuturor funcţiilor
utilizate de program, iar după funcţia main() să le definească. În acest fel, orice
funcţie - mai puţin main() poate fi apelată din oricare alta:

#include <iostream>
using namespace std;
void s1(); // prototip s1
void s2(); // prototip s2
int main()
{ s1();
return 0;
}
void s1()
{ s2(); cout<<"Eu sunt s1"<<endl;
}
void s2()
{ s1(); cout<<"Eu sunt s2"<<endl;
}
 Variabile globale și variabile locale

segment de date
Sistemul de operare alocă fiecărui
program trei zone distincte în segment stivă
memoria internă în care se găsesc
memorate variabilele programului. zona heap

O variabilă se caracterizează prin 4 atribute:

1. Clasa de memorare
Precizează locul unde este memorată variabila respectivă. O
variabilă poate fi memorată în segmentul de date, în cel de stivă, în
heap sau într-un registru al microprocesorului.
2. Vizibilitate
Precizează liniile textului sursă din care variabila
respectivă poate fi accesată. Astfel avem:
• Vizibilitate la nivel de bloc (instrucţiune compusă);
• Vizibilitate la nivel de fişier – în cazul în care
programul ocupă un singur fişier sursă;
• Vizibilitate la nivel de clasă – este în legătură cu
programarea pe obiecte.
3. Durata de viaţă
Reprezintă timpul în care variabila respectivă are alocat spaţiul în
memoria internă. Astfel avem:
• Durata statică – variabila are alocat spaţiu în tot timpul
execuţiei programului (globală)
• Durata locală – variabila are alocat spaţiu în timpul în care se
execută instrucţiunile blocului respectiv (locală)
• Durată dinamică – alocarea şi dezalocarea spaţiului necesar
variabilei respective se face de către programator prin
operatori sau funcţii speciale.

4. Tipul variabilei
Variabile globale:
 Se declară în afara corpului oricărei funcţii. # include <iostream>
 Pot fi utilizate de toate funcţiile care urmează using namespace std;
int a;
în textul sursă declaraţiei variabilei respective. void test()
 La declarare, variabilele globale sunt { a=10;
iniţializate implicit cu 0. cout<<a;
Atributele variabilelor globale sunt: }
1. Clasa de memorare – segmentul de date. int b;
2. Durata de viaţă a variabilelor globale este int main()
statică. Ele au spaţiul de memorie rezervat în tot { b=20;
timpul execuţiei programului. cout<<a<<endl;
test();
3. Vizibilitatea – În cazul în care declaraţiile
return 0;
acestora sunt înaintea tuturor funcţiilor, ele sunt }
vizibile la nivelul întregului program (fişier).
Dacă anumite funcţii se află plasate înaintea
declaraţiilor acestor variabile, atunci ele sunt
vizibile doar pentru funcţiile care sunt plasate
după aceste declaraţii.
Variabile locale:
 Sunt declarate în corpul funcţiilor.
 Variabilele declarate în corpul funcţiei main() sunt locale.

Atributele variabilelor locale sunt:

1. Clasa de memorare a variabilelor locale este, implicit, segmentul de
stivă.
Există posibilitatea ca acestea să fie alocate în registrele
microprocesorului, caz în care declaraţia lor trebuie precedată de
cuvântul cheie “register”.
register int b=4;
Variabilele locale nu sunt iniţializate implicit cu 0. Dacă nu sunt
iniţializate explicit de programator, ele reţin o valoare oarecare, numită
valoare reziduală.
2. Durata de viaţă a variabilelor locale este locală. Trăiesc atâta timp cât
durează executarea funcţiei sau blocului în care au fost definite.
3. Vizibilitatea

 Vizibilitatea variabilelor locale este la

nivelul blocului în care au fost declarate. void t( )
{ int b=4;
În funcţia alăturată am declarat două { int c=3;
variabile de tip int, numite b şi c. Variabila b cout<<b<<” ”<<c;
este vizibilă la nivelul funcţiei, dar variabila }
}
c este vizibilă doar la nivelul blocului în care
a fost declarată.

 Dacă se declară o variabilă locală în int n=4, s=0;

ciclul for ea este vizibilă doar în blocul for (int i=1; i<=n; i++)
s+=i;
for cout<<s;
 #include <iostream>
using namespace std;
int a;
 În cazul în care, într-un anumit void t()
{ int a=4;
bloc sunt vizibile mai multe variabile, toate { int a=3;
cu acelaşi nume, dar au domenii de cout<<a<<endl;
vizibilitate diferite, se accesează variabila cu }
vizibilitatea cea mai mică. cout<<a<<endl;
}
int main()
În programul alăturat se afişează { a=5;
conţinutul tuturor acestor variabile (3,4,5). t();
cout<<a;
return 0;
}