Cateva elemente despre

Functii in C/CPP

Programele pot fi:

 monolitice toate instructiunile se gasesc in main()
 modulare folosim functii (proceduri) – „spargem” programul in module-> ne gandim la avantaje: sunt
programe care au mii de linii si la care trebuie sa lucreze echipe de programatori sau asa cum ai
observat, sunt lucruri care se repeta si ni are rost sa le scrii din nou

Gandim functia ca o procedura, un subprogram. Functiile vor fi apelate din main() sau din alta functie apelata
din main().
Deci programele sunt o ierarhie de apeluri de functii, baza acestei ierarhii fiind functia main()
Pentru a lucra cu functiile trebuie sa stim cum se definesc, cum se declara si cum se apeleaza
1. Definirea functiei
Definitia unei functii consta in:
a. Un antet care contine
Tipul rezultatului intors de functie -> ce tip are valoarea calculata de functie
Numele functiei -> ca sa o putem folosi (sau sa o putem “apela”); regulile pentru nume sunt aceleasi
ca pentru numele variabilelor
Lista parametrilor (formali) -> ce argumente are functia si ce tip are fiecare argument/parametru
b. Blocul de instructiuni
{
instructiuni...
}

adica:
tip_valoare_returnata Nume_Functie (tip_param1 nume_param1, tip_param2 nume_param2, ...)
{
declaratii_variabile_locale
instructiuni...
return valoare_returnata;
}
Deci ce este in dreapta numelui functiei intre paranteze este input-ul functiei ->ce bagam in ea iar ce este in
stanga este output-ul functiei -> ce scoatem din ea.
Se spune parametri formali deoarece ei descriu in mod formal operatiile la care vor fi supuse datele ce vor fi
transmise de programul apelant la executie.
Obs importanta: o functie poate intoarce NUMAI o singura valoare (sau poate executa niste operatii si nu
returneaza nimic: void nume_functie()

2. Declararea functiei (se mai numeste si propotip)

informeaza compilatorul de existenta functiei si formatul acesteia adica specifica numele, tipul rezultatului
intors, si lista parametrilor. Declaratia unei functii este de tipul:

tip_valoare_returnata Nume_Functie (tip_param1 nume_param1, tip_param2 nume_param2, ...);

obs: dupa antet avem „ ; ” la declarare

obs: numele parametrilor poate lipsi; obligatoriu este a specifica tipul parametrilor
ex: int f1(int, int);
ex: void afiseaza() (nu intoarce rezultat, nu are nici parametri)

Definitia unei functii poate sa se gaseasca oriunde, nu neaparat inaintea apelului, posibil si in alte fisiere;
compilatorul trebuie insa sa verifice validitatea apelului functiei, de aceea inaintea oricarui apel este necesar
ca sa apara cel putin declaratia functiei.
Uzual declaratiile se fac la inceputul programului, inainte de functia main() si definitiile functiilor se scriu la
sfarsit, dupa main() sau chiar in alte fisiere. Daca functiile (definitiile) se scriu la inceput, inainte de main()
declaratiile nu mai sunt necesare -->este un exemplu mai incolo.
 3. Apelul functiilor

Cum folosim functia adica. Apelul se poate realiza in 2 moduri:

a. printr-o instructiune de apel
b. ca operand intr-o expresie

a. are forma: nume(lista_parametri_actuali);

nume -> numele functiei
lista_parametri_actuali -> parametrii functiei in ordinea din defintie, separati prin virgula, (pot fi si expresii)
b. are forma: nume(lista_parametri_actuali) --->fara punct si virgula
si se gaseste intr-o expresie, pe post de operand

La apel, valorile parametrilor actuali sunt atribuite, in ordine, parametrilor formali

deci:
Parametrii actuali trebuie sa corespunda ca numar, ordine si tip cu parametrii formali

codul este echivalent, exemplu de apelare a unei functii ca operand intr-o expresie
#include <iostream> #include <iostream>
using namespace std; using namespace std;

int suma(int x, int y) int suma(int x, int y)

{ {
return x+y; int sum;
} sum=x+y;
int main() return sum;
{ }
int a=10, b=20; int main()
cout<<"suma este: "<<suma(a,b); {
return 0; int a=10, b=20, c;
} c=suma(a,b);
cout<<"suma este: "<<c;
return 0;
}
obs: codul de sus ->definita functiei precede apelul, nu e nevoie de declaratie

Acelasi program de mai sus dar definitia functiei este dupa apel; avem nevoie de declaratia functiei (nu uitam
punct si virgula dupa declaratie):
#include <iostream> int suma(int x, int y )
using namespace std; {
int sum;
int suma(int, int ); //declaratia functiei inainte de sum=x+y;
apel return sum;
}
int main()
{
int a=10, b=20, c;
c=suma(a,b);
cout<<"suma este: "<<c;
return 0;
}
//programul se continua in dreapta tabelului
Ex: apelul unei functii din main()

# include<iostream> Cum lucreaza programul?

using namespace std; (toate programele incep de la functia main() deci si acesta)

void display() pas 1. se executa linia 1 – se declara o variabila intreaga a si se

{ initializeaza cu 10
a cout<<"Hello world! ";
b return; pas 2. se ajunge la linia 2 care este un apel la functia display().
} Deci se executa linia a care afiseaza mesajul Hello world pe ecran
int main()
{ pas 3. se executa linia b -> return care transfera executia pe
1 int a=10; prima linie dupa apelul functiei adica linia 3
2 display();
pas 4. se executa linia 3 care afiseaza mesajul „Astazi ai luat...”
3 cout<<"Astazi ai luat nota "<<a;
4 return 0;
pas 5. se executa linia 4 -> return ->se incheie functia main()
}

Recomandare: evitati pe cat se poate interactiunile cu utilizatorul (adica cin>>, cout<< in interiorul functiilor
definite.

Amazing: :-)
In CPP pot exista mai multe functii cu acelasi nume daca difera intre ele fie prin numarul, fie prin tipul
parametrilor:
Acest lucru se numeste Function Overloading <-> supraincarcarea functiilor
In ex urmator avem 3 functii sum():

# include<iostream> int sum(int a,int b,int c) //suma de 3 intregi

using namespace std; {
return a+b+c;
int sum(int a,int b) //suma de 2 intregi }
{ //compilatorul identifica ce functie sa foloseasca
return a+b; dupa
} //numarul si tipul parametrilor

float sum(float a,float b) //suma de 2 nr reale int main()

{ {
return a+b; int x=10,y=5,z=3;
} float q=12.5,w=4.4;
cout<<sum(x,y)<<endl;
cout<<sum(q,w)<<endl;
cout<<sum(x,y,z)<<endl;
return 0;
}

Compilatorul identifica ce functie sa foloseasca dupa numarul si tipul parametrilor. Atentie, fie numarul, fie
tipul parametrilor trebuie sa difere altfel obtinem eroare.

Vom invata ulterior cum utilizeaza functiile memoria. In principiu in memorie se creeaza o zona alocata functiei
si care se sterge cand functia se termina. Zona se numeste stiva - stack.
Sa ne imaginam memoria programului ca un teanc de farfurii- o stiva de farfurii. Apelez o functie=adaug o
farfurie la stiva. Se termina executia functiei->scot farfuria din stiva.
Obs: pot lucra cu stiva de farfurii numai la partea de sus si ultima farfurie pusa va fi prima farfurie scoasa.
Mecanismul se numeste LIFO (Last In First Out)
:-)))))
#include<iostream> #include<iostream>
#include<fstream> #include<fstream>
// functia verifica daca un numar introdus este par // functia verifica daca un numar introdus este prim
using namespace std; using namespace std;

bool nr_par(int nr) bool nr_prim(int nr)

{ {
if(nr%2==0) for(int i=2;i*i<nr;i++)
return true; if(nr%i==0)
return false; { break;
} return false;
int main() }
{ else
int numar; return true;
cout<<"Dati un numar:"; }
cin>>numar; int main()
if(nr_par(numar)) {
cout<<"Nr par"; int numar;
else cout<<"Dati un numar:";
cout<<"Nr impar"; cin>>numar;
return 0; if(nr_prim(numar))
} cout<<"Nr prim";
else
cout<<"Nu este prim";
return 0;