Functii in C++

Functiile sunt instrumete ale limbajului de programare C++ care permit modularizarea programelor.
Atunci cand se observa ca o anumita secventa de instructiuni se poate repeta de mai multe ori in cadrul
unui program, atunci aceasta se inglobeaza in cadrul unei functii, care urmeaza a se apela in cadrul
programului principal ori de cate ori va fi nevoie.

Programul principal este reprezentat tot de o functie: functia main().

Utilizarea functiilor in cadrul unui program presupune cunoasterea urmatoarelor concepte:

 declararea functiei
 prototipul functiei
 apelul functiei in cadrul programului principal sau in cadrul altei functii
 parametrii formali ai functiei
 parametrii efectivi ai functiei
 variabile locale vs variabile globale

     Declararea unei functii

Pentru ca o functie sa poata fi utilizata (apelata) in cadrul unui program, este nevoie ca aceasta sa fie
declarata.

Prin declararea unei functii se specifica:

 tipul functiei
 numele functiei
 lista de parametri formali

Exemplu:

int suma(int a, int b)

     {
          ...
     }

Explicatii:

 int - reprezinta tipul functiei suma

 suma - reprezinta numele functiei
 int a, int b - reprezinta parametrii (formali) ai functiei
 { ... } - reprezinta corpul functiei

Tipul functiei poate fi:

 void
 unul din tipurile de baza ale variabilelor: char, int, float, etc.
Numele functiei este reprezentat de un sir de caractere alfanumerice prin intermediul careuia functia va
fi recunoscuta pe parcursul progrmului

Lista de parametri formali este constituita dintr-o lista de variabile reprezentand valorile care vor fi
preluate din programul principal si transmise functiei. Parametrii formali sunt niste copii sau alias-uri ale
parametrilor efectivi din apelul functiilor.

     Prototipul functiei

In anumite cazuri, este necesar sa lucram cu mai multe functii care se apeleaza reciproc. In aceste cazuri
se se declara prototipul functiilor utilizate, care introduc tipul si numele functiilor, precum si parametrii cu
care acestea opereaza. In felul acesta, atunci can o functie apeleaza pe alta, aceasta va sti care sunt
tipul, numele si parametrii functiei apelate (vezi aici un exemplu de program care foloseste prototipuri de
functii).

Prototipul functiei este amplasat inaintea functiei principale, acesta mai putand fi denumit si declaratia
forward a functiei in sine, aceasta fiind declarata dupa functia main.

Prototipul fiunctiei, spre deosebire de declaratia finctiei, se termina cu (;), iar lista parametrilor formali este
optionala, fiind necesar, in schimb, sa se specifice tipul acestora.

Exemplu:

int suma(int, int);

Explicatii:

 int - reprezinta tipul functiei suma

 suma - reprezinta numele functiei
 int, int - reprezinta tipul parametrilor (formali) ai functiei

     Apelul unei functii

Prin apelul functiei se specifica:

 numele functiei
 lista de parametri efectivi - constituita dintr-o lista de variabile reprezentand valorile din
programul principal care vor fi transmise functiei pentru a fi prelucrate in scopul producerii unui
anumit rezultat.

   Exemplul 1: Sa se realizeze suma patratelor a doua numere introduse de la tastatura, utilizandu-se
apelul unor functii.

1 #include <iostream> a=2

2 using namespace std; b=3
3 int a, b, s; Primul numar la patrat este: 4
4 int suma (int x, int y) Al doilea numar la patrat este: 9
5 { Suma patratelor numerelor este: 13
 6
7
8
9
1
0
1    int rez=x+y;
1    return (rez);
1 }
2 void patrat(int *z)
1 {
3    *z = *z * *z;
1 }
4 int main()
1 {
5    cout<<"a=";cin>>a;
1    cout<<"b=";cin>>b;
6    patrat(&a);
1    patrat(&b);
7    cout<<"Primul numar la patrat este: "<<a<<endl;
1    cout<<"Al doilea numar la patrat este: "<<b<<endl;
8    cout<<"Suma patratelor numerelor este:
1 "<<suma(a,b);
9 }
2
0
2
1
2
2

   Observatii privind parametrii functiei:

 Parametrii formali
o se gasesc la nivelul declaratiei functiilor: int suma (int x, int y);
o preiau valorile date in apelul functiei: suma(a,b) prin intermediul parametrilor efectivi:
valoarea data parametrului efectiv: a (in cadrul programului principal: cin>>a;) - este
transmisa parametrului formal: x, iar valoarea data parametrului efectiv: b (in cadrul
programului principal: cin>>b;) - este transmisa parametrului formal: y
o parametrii formali pot fi considerati niste copii sau alias-uri ale parametrilor efectivi.

 Parametrii efectivi
o se gasesc la nivelul apelului functiei: suma(a,b);
o sunt preluati din cadrul programului apelant (in cazul nostru chiar functia main - cin>>a;
respectiv cin>>b;), valorile acestora transmitandu-se parametrilor formali.

   Explicatii asupra exemplului 1:

 int suma (int x, int y)

{
   int rez=x+y;
   return (rez);
}
 reprezinta declaratia functiei suma, in care:

o int suma (int x, int y) - declara functia de tip int avand numele suma, respectiv un
numar de 2 parametri formali de tip int: x si y. Acestia vor prelua valorile variabilelor a si b
transmise in cadrul apelului functiei:
                         cout<<"Suma patratelor numerelor este: "<<suma(a,b);

o {
   int rez=x+y;
   return (rez);
}

reprezinta corpul functiei suma - locul unde se prelucreaza (insumeaza) valorile date

(prin variabilele / parametrii formali x, respectiv y si se returneaza rezultatul - rez - catre
programul apelant: functia main.

 void patrat(int *z)

{
   *z = *z * *z;
}

reprezinta declaratia functiei patrat, in care:

o void patrat(int *z) - declara functia de tip void avand numele patrat, respectiv un

parametru formal de tip pointer de tip intreg: *z.

o {
   *z = *z * *z;
}

reprezinta corpul functiei patrat - locul unde se realizeaza ridicarea la patrat a variabilei

date prin parametrul formal *z si se returneaza rezultatul progrmului apelant (functiei
main).

 int main() - reprezinta programul principal

 se citesc valorile variabilelor a si b carora li se atribuie valorile 2, respectiv 3

 patrat(&a); respectiv patrat(&b); - reprezinta apelul functiei patrat, utilizate pentru a prelucra cele

2 valori ale celor doua variabile: a si b

 se afiseaza noile valori ale variabilelor in urma apelurilor functiei patrat

 suma(a,b); - reprezinta apelul functiei suma, utilizate pentru calcularea sumei valorilor sticate in
variabilele a si b

Observatie: In cadrul exemplului de mai sus, apelul functiei patrat este un apel prin referinta, in timp ce
apelul functiei suma este un apel prin valoare.
   Exemplul 2: Sa se realizeze suma patratelor a doua numere introduse de la tastatura, urmarindu-se
prototipul, declaratia, respectiv apelul unor functii.

1
2
3
4
5
6
7
8 #include <iostream> a=2
9 using namespace std; b=3
1 int a, b, s; Primul numar la patrat este: 4
0 int suma (int, int); Al doilea numar la patrat este: 9
1 void patrat(int *); Suma patratelor numerelor este: 13
1 int main()
1 {
2    cout<<"a=";cin>>a;
1    cout<<"b=";cin>>b;
3    patrat(&a);
1    patrat(&b);
4    cout<<"Primul numar la patrat este: "<<a<<endl;
1    cout<<"Al doilea numar la patrat este: "<<b<<endl;
5    cout<<"Suma patratelor numerelor este:
1 "<<suma(a,b);
6 }
1 int suma (int x, int y)
7 {
1    int rez=x+y;
8    return (rez);
1 }
9 void patrat(int *z)
2 {
0    *z = *z * *z;
2 }
1
2
2
2
3
2
4

Explicatii:

 int suma (int, int);

o reprezinta prototipul functiei suma.
o nu este obligatoriu ca numele parametrilor formali sa fie prezenti la nivelul prototipului
functiei.
o la nivelul prototipului se specifica tipul finctiei (int), tipul, respectiv numarul parametrilor: 2
(int, int)

 void patrat(int *);

o reprezinta prototipul functiei patrat.
 o nu este obligatoriu ca numele parametrilor formali sa fie prezenti la nivelul prototipului
functiei.
o la nivelul prototipului se specifica tipul finctiei (void), tipul, respectiv numarul parametrilor:
1 (int *)
o remarca: in cazul functiei patrat, parametrul este un pointer la tipul int.

 int main() - reprezinta programul principal

 se citesc valorile variabilelor a si b carora li se atribuie valorile 2, respectiv 3

 patrat(&a); respectiv patrat(&b); - reprezinta apelul functiei patrat, utilizate pentru a prelucra cele

2 valori ale celor doua variabile: a si b

 se afiseaza noile valori ale variabilelor in urma apelurilor functiei patrat

 suma(a,b); - reprezinta apelul functiei suma, utilizate pentru calcularea sumei valorilor sticate in
variabilele a si b

 int suma (int x, int y)

{
   int rez=x+y;
   return (rez);
}

reprezinta declaratia functiei suma, in care:

o int suma (int x, int y) - declara functia de tip int avand numele suma, respectiv un
numar de 2 parametri formali de tip int: x si y. Acestia vor prelua valorile variabilelor a si b
transmise in cadrul apelului functiei:
                         cout<<"Suma patratelor numerelor este: "<<suma(a,b);

o {
   int rez=x+y;
   return (rez);
}

reprezinta corpul functiei suma - locul unde se prelucreaza (insumeaza) valorile date

(prin variabilele / parametrii formali x, respectiv y si se returneaza rezultatul - rez - catre
programul apelant: functia main.

 void patrat(int *z)

{
   *z = *z * *z;
}

reprezinta declaratia functiei patrat, in care:

o void patrat(int *z) - declara functia de tip void avand numele patrat, respectiv un

parametru formal de tip pointer de tip intreg: *z.

o {
   *z = *z * *z;
 }

reprezinta corpul functiei patrat - locul unde se realizeaza ridicarea la patrat a variabilei

date prin parametrul formal *z si se returneaza rezultatul progrmului apelant (functiei
main).

     Variabile globale vs variabile locale

Asa cum am mai mentionat si in cadrul capitolului Variabile si tipuri de date, pentru a rezolvarea
problemelor avem nevoie de variabile, in functie de locul in care sunt declarate, acestea clasificandu-se
in:

 variabile globale
 variabile locale

Variabilele globale sunt variabilele declarate in afara functiei main, si sunt "recunoscute" atat in
programul principal cat si in functiile adiacente acestuia. Variabilele globale sunt initailizate in momentul
declararii cu valoarea 0.

Variabilele locale sunt variabilele declarate in interiorul unei functii (inclusiv in nteriorul functiei main) si
sunt "recunoscute" doar la nivelul functiilor in care acestea au fost declarate. In absenta unei initializari
prealabile, valoarea unei variabile locale este una aleatoare, aflata la momentul respctiv la adresa de
memorie corespunzatoare variabilei declarate.

   Exemplul 3: Sa se realizeze suma a doua numere introduse de la tastatura, utilizandu-se apelul unei
functii.

1 #include <iostream> 4286094

2 using namespace std; 0
3 int a, b; 0
4 int suma (int x, int y) a=2
5 { b=3
6    int rez=x+y; Suma numerelor este: 5
7    //cout<<s; 4286094
8    return (rez);
9 }
1 int main()
0 {
1    int s;
1    cout<<s<<endl;
1    cout<<a<<endl;
2    cout<<b<<endl;
1    cout<<"a=";cin>>a;
3    cout<<"b=";cin>>b;
1    cout<<"Suma numerelor este:
4 "<<suma(a,b)<<endl;
1    //cout<<rez;
5    cout<<s<<endl;
1 }
6
1
7
1
 8
1
9
2
0
2
1

Explicatii:

 Varibilele a si b sunt variabile globale, recunoscute pe parcursul intregului program;

 Variabila s este o variabila locala functiei main si este recunoscuta doar pe parcursul acesteia.
Daca incercam sa-i afisam valoarea in cadrul altei functii (suma), obtinem eroare la compilare.
 Variabila rez este o variabila locala functiei suma si este recunoscuta doar pe parcursul acesteia.
Daca incercam sa-i afisam valoarea in cadrul altei functii (int), obtinem eroare la compilare.

Apelul prin valoare al functiilor

Forma generala:

tip_functie nume_functie(tip_var_1 var_1, ... , tip_var_n var_n)

{
     instructiune 1;
     ...
     instructiune n;
     return nume_var_ret;
}

unde:

 tip_functie - reprezinta tipul functiei

 nume_functie - reprezinta identificatorul cu ajutorul caruia functia va fi apelata pe parcursul
programului
 lista de parametri formali:
o tip_var_1...tip_var_n - reprezinta tipul variabilelor/parametrilor formali
o var_1...var_n - reprezinta parametrii formali ai functiei
 intre acolade se trece corpul functiei - setul de instructiuni ce va prelucra parametrii formali in
scopul returnarii unui rezultat.
 nume_var_ret - reprezinta valoarea retunata de catre functie programului/functiei apelante
(functia main sau alta functie care o poate apela.

Exemplu:

     int suma (int x, int y)

     {
         int rez=x+y;
         return rez;
     }

Explicatii:
  int - tipul functiei: valoarea pe care functia o va returna programului/functiei apelante va fi de tip
int;
 suma - numele functiei;
 int x, int y - lista de parametri formali ai functiei suma: doua variabile (x, y) de tip int;
 int rez - declararea unei variabile locale functiei suma, in care se va stoca direct suma dintre
valorile variabilelor x si y;
 return rez - comanda prin care functia suma intoarce programului/functiei apelante valoarea
calculata anterior in variabila rez.

Observatii:

1. tipul functiei poate sa fie void - in acest caz, functia nu va returna nici o valoare
programului/functiei apelante (nu va mai fi nevoie de intructiunea return;
2. lista de parametri formali este optionala, putand exista functii in care acestia sa nu existe
3. cand exista mai multe functii care se apeleaza reciproc, se foloseste prototipul functiilor (vezi
conceptele functiilor prezentate in capitolul anterior;
4. asa cum am mai explicat si aici, parametrii formali ai functiei: int suma(int x, int y) reprezinta
niste copii/aliasuri ale parametrilor efectivi din apelul functiei: suma(a,b)

o int suma(int x, int y) ==> declaratia functiei ==> parametri formali: x si y;

o suma(a,b) ==> apelul functiei ==> parametri efectivi: a si b;

Exemplul 1: Sa se calculeze suma a doua numere citite de la tastatura.

1
2
3 #include <iostream> a=2
4 using namespace std; b=3
5 int a, b, s; Suma numerelor 2 si 3 este: 5
6 int suma (int x, int y)
7 {
8    int rez=x+y;
9    return rez;
1 }
0 int main()
1 {
1    cout<<"a=";cin>>a;
1    cout<<"b=";cin>>b;
2    cout<<"Suma numerelor "<<a<<" si "<<b<<" este:
1 "<<suma(a,b);
3 }
1
4

Exemplul 2: Sa se calculeze suma a doua numere citite de la tastatura (folosindu-se o functie void).

1 #include <iostream> a=2

2 using namespace std; b=3
3 int a, b, s; Suma numerelor 2 si 3 este: 5
4 void suma (int x, int y)
5 {
6    int rez=x+y;
7    cout<<rez;
8 }
9 int main()
 1
0
1
{
1
   cout<<"a=";cin>>a;
1
   cout<<"b=";cin>>b;
2
   cout<<"Suma numerelor "<<a<<" si "<<b<<" este:
1
";
3
   suma(a,b);
1
}
4
1
5

Exemplul 3: Sa se calculeze suma a doua numere citite de la tastatura (folosindu-se o functie void fara
parametri).

1
2
3
4 #include <iostream> a=2
5 using namespace std; b=3
6 void suma () Suma numerelor 2 si 3 este: 5
7 {
8    int a, b, s;
9    cout<<"a=";cin>>a;
1    cout<<"b=";cin>>b;
0    s=a+b;
1    cout<<"Suma numerelor "<<a<<" si "<<b<<" este:
1 "<<s;
1 }
2 int main()
1 {
3    suma();
1 }
4
1
5

Apelul prin referinta al functiilor

Forma generala:

void nume_functie(tip_var_1 var_1, ... , tip_var_n &var_n)

{
     instructiune 1;
     ...
     instructiune n;
}

unde:

 void - reprezinta tipul functiei

  nume_functie - reprezinta identificatorul cu ajutorul caruia functia va fi apelata pe parcursul
programului
 lista de parametri formali:
o tip_var_1...tip_var_n - reprezinta tipul variabilelor/parametrilor formali
o &var_1...&var_n - reprezinta parametrii formali ai functiei
 intre acolade se trece corpul functiei - setul de instructiuni ce va prelucra parametrii formali in
scopul returnarii unui rezultat.

Exemplu:

     void schimba (int &x, int &y)

     {
         int temp;
         temp=x;
         x=y;
         y=temp;
     }

Explicatii:

 void - tipul functiei este void deoarece functia, in cazul de fata, nu intoarce un alt rezultat
programului/functiei apelante, ca in cazul apelurilor prin valoare;
 schimba - numele functiei;
 int &x, int &y - lista de parametri formali ai functiei schimba: acesti parametri reprezinta adresele
de memorie a doua variabile (&x, &y) de tip int;
 int temp - declararea unei variabile locale functiei schimba, in care se va stoca temporar
valoarea aflata la o adresa de memorie corespunzatoare variabilelor x si y
 temp=x; x=y; y=temp; - interschimbarea valorilor aflate la adresele de memorie &x si &y

Observatii:

1. tipul functiei este void - in acest caz, functia nu va returna nici o alta valoare programului/functiei
apelante
2. lista de parametri formali este obligatorie, functia producand rezultate numai prin intermediul
acestora
3. cand exista mai multe functii care se apeleaza reciproc, se foloseste prototipul functiilor (vezi
conceptele functiilor prezentate in capitolul anterior);
4. spre deosebire de cazul apelului prin valoare al functiilor, in cazul apelului prin referinta,
parametrii formali nu mai sunt niste copii ale parametrilor efectivi ai functilor ci chiar adresele de
momorie alea acestora. Astfel, operatiile efectuate in cadrul functiilor se vor efectua direct asupra
acestor variabile, schimbandu-le valoarea.

Exemplul 1: Sa se interschimbe valorile a doua variabile prin intermediul unei functii.

1 #include <iostream> x=2

2 using namespace std; y=3
3 int x, y; Inaintea apelului functiei: x=2 si y=3
4 void schimba (int &x, int &y) Valorile variabilelor in cadrul functiei:
5 { temp=2
6    int temp; x=2
7    cout<<"Valorile variabilelor in cadrul functiei:"<<endl; y=3
8    temp=x;
 9
1
0
1
1
1
2
1
3
   cout<<"temp="<<temp<<endl; x=3
1
   cout<<"x="<<x<<endl; y=3
4
   cout<<"y="<<y<<endl<<endl;
1
   x=y; temp=2
5
   cout<<"x="<<x<<endl; x=3
1
   cout<<"y="<<y<<endl<<endl; y=2
6
   y=temp;
1
   cout<<"temp="<<temp<<endl; Dupa apelului functiei: x=3 si y=2
7
   cout<<"x="<<x<<endl;
1
   cout<<"y="<<y<<endl<<endl;
8
}
1
int main()
9
{
2
   cout<<"x=";cin>>x;
0
   cout<<"y=";cin>>y;
2
   cout<<"Inaintea apelului functiei: x="<<x<<" si
1
y="<<y<<endl;
2
   schimba(x,y);
2
   cout<<"Dupa apelului functiei: x="<<x<<" si y="<<y<<endl;
2
}
3
2
4
2
5
2
6
2
7

Observatii:

 In programul de mai sus, numele parametrilor efectivi este acelasi cu numele parametrilor formali.
Parametrii formali preiau adresele parametrilor efectivi si, de aceea, apar aceleasi nume de
variabile atat in lista de parametri afectivi (in apelul functiei) cat si in lista de parametri formali (in
definitia functiei);
 Daca in cadrul programului de mai sus utilizam apelul prin valoare, atunci:
o parametrii formali nu vor mai fi adrese de variabile ci copii ale acestora (cu alt
nume/identificator
o numele variabilelor utilizate in lista de parametrii formali (din definitia functiei) este diferit
de numele utilizate in lista de parametri efectivi (din apelul functiei)
o valorile variabilelor ce se doresc a fi interschimbate (date in programul principal si
transmise prin parametrii efectivi ai apelului functiei) nu se vor schimba
o valorile parametrilor formali se vor schimba in cadrul functiei - fara a afecta valorile
parametrilor afectivi ai functiei.
o Scopul de a interschimba valorile a doua variabile nu va fi atins.

1 #include <iostream> a=2

2 using namespace std; b=3
 3
4
5
6
7
8
9
1
0
int a, b; Inaintea apelului functiei: a=2 si b=3
1
void schimba (int x, int y) Valorile variabilelor in cadrul functiei:
1
{ temp=2
1
   int temp; x=2
2
   cout<<"Valorile variabilelor in cadrul functiei:"<<endl; y=3
1
   temp=x;
3
   cout<<"temp="<<temp<<endl; x=3
1
   cout<<"x="<<x<<endl; y=3
4
   cout<<"y="<<y<<endl<<endl;
1
   x=y; temp=2
5
   cout<<"x="<<x<<endl; x=3
1
   cout<<"y="<<y<<endl<<endl; y=2
6
   y=temp;
1
   cout<<"temp="<<temp<<endl; Dupa apelului functiei: a=2 si b=3
7
   cout<<"x="<<x<<endl;
1
   cout<<"y="<<y<<endl<<endl;
8
}
1
int main()
9
{
2
   cout<<"a=";cin>>a;
0
   cout<<"b=";cin>>b;
2
   cout<<"Inaintea apelului functiei: a="<<a<<" si
1
b="<<b<<endl;
2
   schimba(a,b);
2
   cout<<"Dupa apelului functiei: a="<<a<<" si b="<<b<<endl;
2
}
3
2
4
2
5
2
6
2
7

Exemplul 2: Sa se afle patratul unui numar prin intermediul unei functii cu apel prin referinta.

1 #include <iostream> a=2

2 using namespace std; Inaintea apelului functiei: a=2
3 int a; Dupa apelului functiei: a=4
4 void patrat (int &a)
5 {
6    a=a*a; }
7 int main()
8 {
9    cout<<"a=";cin>>a;
1    cout<<"Inaintea apelului functiei:
0 a="<<a<<endl;
1    patrat(a);
1    cout<<"Dupa apelului functiei: a="<<a<<endl;
1 }
 2
1
3

Functii recursive
O functie recursiva este o functie care se autoapeleaza, adica, cel putin una dintre instructiunile
compoenete ale sale reprezinta apelul aceleiasi functii, dar, cu o alta iteratie. Iteratia functiei este
reprezentata de valoarea curenta a parametrului/prametrilor functiei.

Exemplu:

     int suma (int x)

     {
         if (x==0)
            return x;
         else
            return x+suma(x-1);
     }

Explicatii:

 Corpul functiei suma contine apelul aceleiasi functii pe o iteratie inferioara: suma(x-1). Valoarea
curenta a rezultatului functiei depinde de valoarea anterioara a acestuia.
 Corpul functiei contine conditia de iesire din recursivitate: if (x==1). Rezultatul apelului functiei
este conditionat de valoarea iteratiei functiei. Pentru valoarea minima a iteratiei (x==1) se
returneaza o valoare fixa (x), iar pentru restul iteratiilor se returneaza o valoare calculata, plecand
de la valoarea returnata de prima iteratie (x+suma(x-1)).

Reguli generale pentru utilizarea functiilor recursive

 Corpul unei functii recursive contine:

o valoarea de baza, de la care se pleaca in construirea solutiei;
o formula generala, dupa care se calculeaza valoarea functiei la fiecare iteratie; La acest
nivel vom intalni autoapelul functiei recursive.
o conditia de iesire din recursivitate - in absenta acesteia, functia riscand sa intre intr-o
bucla infinita

 Functiile recursive sunt functii care se autoapeleaza, in felul acesta creindu-se o structura
repetitiva (atentie, a nu se confunda cu structurile repetitive descrise in capitolele
anterioare: for, while, do..while).

 Functiile recursive trebuie sa aiba indeplinita conditia de consistenta. Conditia de consistenta

presupune ca prelucrarea parametrilor locali ai functiei recursive, conduc catre valoarea de baza,
de la care se pleaca in construirea solutiei.
Exemplul 1: Sa se calculeze suma primelor n numere naturale (n va fi citit de la tastatura).

1
2
3
4
5
#include <iostream> n=4
6
using namespace std; 0
7
int n; 1
8
int suma (int x) 3
9
     { 4
1
        int ret; 10
0
        if (x==0) Suma primelor 4 numere naturale este: 10
1
           ret=x;
1
        else
1
           ret=x+suma(x-1);
2
           cout<<ret<<endl;
1
        return ret;
3
     }
1
int main()
4
{
1
   cout<<"n=";cin>>n;
5
   int s=suma(n);
1
   cout<<"Suma numerelor "<<n<<" numere naturale este:
6
"<<s;
1
}
7
1
8
1
9

Explicatii:

1. Metoda:
1. se pleaca de la solutia matematica - pentru n=4 avem:
 suma(4)=4+suma(3)
 suma(3)=3+suma(2)
 suma(2)=2+suma(1)
 suma(1)=1+suma(0)
 suma(0)=0
2. recursiv (de la valoarea de baza - suma(0) - catre ultima valoare - suma(4)), vom calcula
suma finala :
 suma(0)=0
 suma(1)=1+suma(0)=1+0=1
 suma(2)=2+suma(1)=2+1=3
 suma(3)=3+suma(2)=3+3=6
 suma(4)=4+suma(3)=4+6=10
2. In program:
1. se citeste variabila n
2. se apeleaza functia suma(n) si se atribuie variabilei s;
3. functia suma contine:
 declararea unei variabile locale ret care va returna valoarea functiei catre
programul/functia apelanta - functia main;
 valoarea de baza, de la care se pleaca in construirea solutiei: 0;
 formula generala, dupa care se calculeaza valoarea functiei la fiecare iteratie:
x+suma(x-1);
  conditia de iesire din recurenta: x==0;
4. mod de lucru:
 parametrul formal x preia valoarea parametrului efectiv n: n=4 => x=4
 se testeaza valoarea lui x
 deoarece valoarea lui x este 4, deci x!=0 se merge pe varianta else a conditiei:
ret=x+suma(x-1); ret va avea deci valoarea: 4+suma(x-1) => autoapel al functiei
suma dar pentru iteratia x=x-1=3
 se retesteaza valoarea lui x
 deoarece valoarea lui x este 3, deci x!=0 se merge pe varianta else a conditiei:
ret=x+suma(x-1); ret va avea deci valoarea: 4 (din iteratia anterioara) + 3 +
suma(x-1) => autoapel al functiei suma dar pentru iteratia x=x-1=2
 se retesteaza valoarea lui x
 deoarece valoarea lui x este 2, deci x!=0 se merge pe varianta else a conditiei:
ret=x+suma(x-1); ret va avea deci valoarea: 4 + 3 (din iteratiile anterioare) + 2 +
suma(x-1) => autoapel al functiei suma dar pentru iteratia x=x-1=1
 se retesteaza valoarea lui x
 deoarece valoarea lui x este 1, deci x!=0 se merge pe varianta else a conditiei:
ret=x+suma(x-1); ret va avea deci valoarea: 4 + 3 + 2 (din iteratiile anterioare) +
1 + suma(x-1) => autoapel al functiei suma dar pentru iteratia x=x-1=0
 se retesteaza valoarea lui x
 deoarece valoarea lui x este 0, deci x==0 se merge pe varianta adevarata a
conditiei: ret=x=0; aceasta reprezinta valoarea de baza: suma(0)=0, de la care se
pleaca in construirea solutiei
 din acest punct se incepe, recursiv, construirea solutiei, conform formulelor de la
punctul 1.2 :

 valoarea de baza:suma(0) se transmite functiei pe iteratia curenta:

        suma(1)=1+suma(0)=1+0=1

 valoarea functiei pe iteratia anterioara: suma(1) se transmite functiei pe

iteratia curenta:

        suma(2)=2+suma(1)=2+1=3

 valoarea functiei pe iteratia anterioara: suma(2) se transmite functiei pe

iteratia curenta:

        suma(3)=3+suma(2)=3+3=6

 valoarea functiei pe iteratia anterioara: suma(3) se transmite functiei pe

iteratia curenta:

        suma(4)=4+suma(3)=4+6=10

 Valoarea 10 a functiei suma (preluata din variabila returnata: ret), va fi transmisa

functiei main prin intermediul apelului functei suma(n) si va fi staocata in variabila
s: s=suma(n);

Exemplul 2: Sa se calculeze valoarea lui n factorial (n!) - n va fi citit de la tastatura.

1 #include <iostream> n=4

2 using namespace std; 1
3 int n; 2
4 int nfact (int x) 6
 5
6
7
8
9
1      { 24
0         int ret; 4!=24
1         if (x==1)
1            ret=1;
1         else
2            ret=x*nfact(x-1);
1            cout<<ret<<endl;
3         return ret;
1      }
4 int main()
1 {
5    cout<<"n=";cin>>n;
1    int nf=nfact(n);
6    cout<<n<<"!="<<nf;
1 }
7
1
8
1
9

Explicatii:

1. Metoda:
1. se pleaca de la solutia matematica - pentru n=4 avem:
 nfact(4)=4+nfact(3)
 nfact(3)=3+nfact(2)
 nfact(2)=2+nfact(1)
 nfact(1)=1+nfact(0)
 nfact(0)=0
2. recursiv (de la valoarea de baza - nfact(0) - catre ultima valoare - nfact(4)), vom calcula
valoarea finala :
 nfact(0)=0
 nfact(1)=1+nfact(0)=1+0=1
 nfact(2)=2+nfact(1)=2+1=3
 nfact(3)=3+nfact(2)=3+3=6
 nfact(4)=4+nfact(3)=4+6=10
2. In program:
1. se citeste variabila n
2. se apeleaza functia nfact(n) si se atribuie variabilei s;
3. functia nfact contine:
 declararea unei variabile locale ret care va returna valoarea functiei catre
programul/functia apelanta - functia main;
 valoarea de baza, de la care se pleaca in construirea solutiei: 1;
 formula generala, dupa care se calculeaza valoarea functiei la fiecare iteratie:
x+nfact(x-1);
 conditia de iesire din recurenta: x==1;
4. mod de lucru:
 parametrul formal x preia valoarea parametrului efectiv n: n=4 => x=4
 se testeaza valoarea lui x
 deoarece valoarea lui x este 4, deci x!=1 se merge pe varianta else a conditiei:
ret=x*nfact(x-1); ret va avea deci valoarea: 4*nfact(x-1) => autoapel al functiei
nfact dar pentru iteratia x=x-1=3
 se retesteaza valoarea lui x
 deoarece valoarea lui x este 3, deci x!=1 se merge pe varianta else a conditiei:
ret=x*nfact(x-1); ret va avea deci valoarea: 4 (din iteratia anterioara) * 3 * nfact(x-
1) => autoapel al functiei nfact dar pentru iteratia x=x-1=2
 se retesteaza valoarea lui x
 deoarece valoarea lui x este 2, deci x!=1 se merge pe varianta else a conditiei:
ret=x*nfact(x-1); ret va avea deci valoarea: 4 * 3 (din iteratiile anterioare) * 2 *
nfact(x-1) => autoapel al functiei nfact dar pentru iteratia x=x-1=1
 se retesteaza valoarea lui x
 deoarece valoarea lui x este 1, deci x==1 se merge pe varianta adevarata a
conditiei: ret=x=1; aceasta reprezinta valoarea de baza - nfact(1)=1 - de la care
se pleaca in construirea solutiei
 din acest punct se incepe, recursiv, construirea solutiei, conform formulelor de la
punctul 1.2 :

 valoarea de baza - nfact(1) - se transmite functiei pe iteratia curenta:

        nfact(2)=2*nfact(1)=2*1=2

 valoarea functiei pe iteratia anterioara nfact(2) se transmite functiei pe

iteratia curenta:

        nfact(3)=3*nfact(2)=3*2=6

 valoarea functiei pe iteratia anterioara: nfact(3) se transmite functiei pe

iteratia curenta:

        nfact(4)=4*nfact(3)=4*6=24

 Valoarea 24 a functiei nfact (preluata din variabila returnata: ret), va fi transmisa

programului apelant (functiei main) prin intermediul apelului functei nfact(n) si va
fi staocata in variabila nf: nf=nfact(n);