Subprograme

LECȚIA 2 Anatomia unei funcții C++

Modalități de realizare a apelului

Prof. Daniela Stratulat

 Tipuri de funcții
În C++ funcțiile definite de utilizator pot fi de două tipuri:

Funcție operand (funcție cu tip): subprogram care returnează

un rezultat chiar prin numele lui; tipul unei funcţii operand (tipul
valorii întoarse) poate fi: numeric (întreg sau real), caracter,
pointer, înregistrare (struct), NU poate fi tablou (vector, matrice,
string);

Funcție procedurală: subprogram care îndeplinește o sarcină și

nu returnează un rezultat (de exemplu, citirea unor variabile,
afișarea unor valori, transformarea unor date); un astfel de
subprogram poate returna mai multe valori prin intermediul
parametrilor; tipul unei funcţii procedurale este void (nici un tip);
 Structura unei funcții
Antet - acesta conţine mai multe informaţii importante și anume:
numele funcţiei, lista parametrilor formali, tipul rezultatului.
Structura antetului este:
tip_functie nume_functie (lista_parametrilor_formali)
Lista parametrilor formali este de forma:
tip parametru1, tip parametru2, ..., tip parametrun
Exemple de antete
int suma(int a, int b) - funcţia se numeşte suma, returnează un rezultat de tip int şi are
doi parametri formali de tip int, numiţi a şi b.
void t(int n, float v[20]) - funcţia se numeşte t, este de tip void (nu returnează rezultat
prin nume), are doi parametri formali, primul numit n, de tip int, al doilea numit v, de
tip float* (un tip care reţine adrese de vectori cu elemente de tipul float).
Corp (instrucţiune compusă) - cuprinde declaraţiile variabilelor
locale, şi instrucţiunile propriu-zise.
Apelul funcțiilor
O funcţie poate fi apelată printr-o instrucţiune de apel, de
forma: nume_funcţie (lista_parametrilor_efectivi);
Parametrii efectivi trebuie să corespundă cu cei formali ca
număr, ordine şi tip.
Exemplu de apel al unei funcții  apelul unei funcții operand (cu tip) se
ce returnează o valoare realizează în cadrul unor expresii,
instrucțiuni de atribuire, instrucțiuni de
#include <iostream>
control (if, while, for) sau chiar ca
using namespace std;
parametrii ai unei alte funcții (de
exemplu: if (prim(invers(x)));
int prod (int x, int y)
{ return x*y; }
 O funcţie cu tip returnează rezultatul la
întâlnirea instrucţiunii return, care are
int main()
forma: return expresie;
{ int x=2,y=3;
cout<<1+prod(x,y); //apel
 Trebuie ca tipul expresiei să coincidă cu
return 0;
tipul funcţiei.
}
 Exemplu de apel al unei funcții
ce nu returnează o valoare

#include <iostream>
 O funcţie procedurală (fără tip)
using namespace std; poate fi apelată de sine stătător
void suma (int n) (prin nume şi lista parametrilor
{ int i, s=0; efectivi)
for(i=1; i<=n; i++)
s=s+i;
cout<<s;
 În absenţa instrucţiunii return,
} execuţia funcţiei se încheie
int main() după execuţia ultimei
{ int n; instrucţiuni. În acest caz nu se
cout<<”n=”; cin>>n; întoarce nicio valoare.
suma(n); //apel
return 0;
}
Modalitatea de execuție a unui
program care conține funcții
#include <iostream>
În momentul în care se întâlneşte
using namespace std;
un apel de funcţie, controlul execuţiei
programul este transferat primei instrucţiuni int cmmdc(int x, int y)
din funcția apelată, urmând a se executa { while(x!=y)
secvenţial instrucţiunile acesteia. if(x>y) x=x-y;
Revenirea dintr-o funcţie se face în unul din else y=y-x;
următoarele cazuri: return x;
 după execuţia ultimei instrucţiuni din }
corpul funcţiei;
 la întâlnirea unei instrucţiuni return; int main()
{ int a,b;
La revenirea din funcţia apelată, controlul este
cin>>a>>b;
redat funcţiei apelante, şi execuţia continuă cu cout<<cmmdc(a,b);
instrucţiunea următoare instrucţiunii de apel, }
din funcţia apelantă.
 Problema 1 Se dau două numere naturale n și m. Să se determine suma dintre
oglinditul lui n și oglinditul lui m.
#include <iostream>  funcția are antetul int oglindit (int x) din care deducem
using namespace std; numele funcției, parametrul și tipul rezultatului întors;
int oglindit(int x)  funcția are un bloc de instrucțiuni, corpul funcției,
{ delimitat de acolade { }, care precizează operațiile prin
int r=0; care se obține rezultatul.
while(x!=0)  corpul funcției are propriile variabile (aici r) care se
{ numesc variabile locale;
r=10 * r + x % 10;  în corpul funcției, parametrul se comportă ca o variabilă
x=x/10; locală. NU putem avea o variabilă locală cu același
} identificator ca parametrul;
return r;  în corpul funcției nu se cunosc valorile parametrilor
} formali. Funcția trebuie să determine rezultatul corect
indiferent de valoarea lor;
int main(){  rezultatul determinat în cadrul funcției este întors în
int n,m; programul apelant prin instrucțiunea return r;
cin>>n>>m;  în funcția main găsim apelul funcției oglindit, apelul
cout<<oglindit(n)+oglindit(m); funcției se face într-o expresie:
return 0; cout << oglindit(n)+oglindit(m);.
}  parametrii n, m, întâlniți în apel, se numesc parametri
efectivi. Valorile parametrilor actuali sunt cunoscute;
 Problema 2 Se dă n număr natural. Să se determine dacă cifra maximă a
numărului n este pară sau nu.
#include <iostream>
using namespace std;

int cmax(int a)
{
int maxi=0; int main()
while(a!=0) {
{ int n;
if(a%10>maxi) cin>>n;
maxi=a%10; int b=cmax(n);
a=a/10; cout<<paritate(b);
} return 0;
return maxi; }
}
int paritate(int p)
{
if(p%2==0) p=1;
else p=0;
return p;
}