PROGRAMAREA IN

LIMBAJELE C/C++

Note de curs 2019-2020

Diana Stefanescu
Diana.Stefanescu@ugal.ro

FUNCTII 1
 CUPRINS
1. NOŢIUNI INTRODUCTIVE
2. DATE, OPERATORI ŞI EXPRESII
3. IMPLEMENTAREA STRUCTURILOR DE CONTROL
4. TABLOURI
5. POINTERI
6. FUNCŢII
7. TIPURI DE DATE DEFINITE DE UTILIZATOR
8. FISIERE

FUNCTII 2
CAPITOLUL 6

FUNCTII

FUNCTII 3
 CAP.6. FUNCTII
1. Structura unei funcţii
1. Declaraţii şi definiţii de funcţii
2. Apelul funcţiilor
2. Transferul parametrilor unei funcţii
1. Transferul parametrilor prin valoare
2. Transferul parametrilor prin pointeri
3. Transferul parametrilor prin referinţă
4. Tablouri ca parametri
5. Transferul parametrilor către funcţia main

FUNCTII 4
 CAP.6. FUNCTII
3. Funcţii cu parametrii impliciţi
4. Funcţii cu număr variabil de parametri
5. Funcţii predefinite
6. Supraîncărcarea funcţiilor
7. Clase de memorare
8. Moduri de alocare a memoriei
9. Funcţii recursive
10. Pointeri către funcţii
FUNCTII 5
 1. Structura unei functii
 Program C/C++ = ansamblu de funcţii
 Conceptual, funcţia reprezintă o aplicaţie definită pe o
mulţime D (D=mulţimea, domeniul de definiţie), cu
valori în mulţimea C (C=mulţimea de valori,
codomeniul), care îndeplineşte condiţia că oricărui
element din D îi corespunde un unic element din C.
 Funcţiile comunică prin argumente.
 Strcuctura unei functii:
 antet
 corp

FUNCTII 6
 Structura unei functii (cont)
<antet_funcţie>
{
<corpul_funcţiei>
}

<tip_v_ret> <nume_func>(<lista_decl_param_ formali>)

{
<declaraţii_variabile_locale>
<instrucţiuni>
[return <valoare>;]
}

FUNCTII 7
 Declaratii si definitii de functii
 In C/C++:
 declaratii de functii
 definitii de functii
 Declaraţia - specificarea antetului funcţiei;
 rolul de a informa compilatorul asupra tipului, numelui funcţiei
şi a listei declaraţiilor parametrilor formali.
 Prototipuri = declaraţii de funcţii din care lipsesc numele
parametrilor formali.
 Definiţia = antetul funcţiei + corpul acesteia.
 OBS: Nu este admisă definirea unei funcţii în corpul altei
funcţii.

FUNCTII 8
 Apelul functiilor
 Prin “instructiuni de apel”:
<numeFct> (<ListaParametrilorEfectivi>);
 Parametri formali
 Parametri efectivi
 Utilizarea parametrilor formali la implementarea
funcţiilor şi atribuirea de valori concrete pentru ei, la
execuţie, reprezintă un prim nivel de abstractizare în
programare.
 Acest mod de programare se numeşte programare
procedurală şi realizează un proces de
abstractizare prin parametri.

FUNCTII 9
Exemple

FUNCTII 10
Exemple

FUNCTII 11
Exemple

(2*i*x);

FUNCTII 12
Exemple

(2*i*x);

FUNCTII 13
2. Transferul parametrilor unei functii
 Modalitati de transfer a parametrilor:
 prin valoare (specific limbajului C)
 prin pointeri
 prin referinta (specific limbajului C++)
 O functie poate returna:
 valoare
 pointer
 referinta

FUNCTII 14
Transferul parametrilor prin valoare
 Incarcarea valorilor parametrilor efectivi in zona de
memorie a parametrilor formali (în stivă)

FUNCTII 15
Transferul parametrilor prin valoare
 Caracteristici:
 Transferul datelor este unidirecţional, adică valorile se transferă
numai de la funcţia apelantă către cea apelată: orice modificare
a valorii parametrului formal în funcţia apelată (printr-o
operaţie din corpul funcţiei), va determina doar modificarea
copiei locale a parametrului efectiv, neinfluenţând în nici un
mod valoarea parametrului efectiv corespunzător.
 Parametrii efectivi pot fi expresii sau nume de variabile.
 Specific limbajului C (numit limbajul apelului prin valoare)
 Transferul valorii parametrilor este însoţit de eventuale conversii
de tip.
 Functiile pot returna valori!
FUNCTII 16
Transferul parametrilor prin pointeri
 Parametrii efectivi sunt pointeri (variabile care conţin
adrese): parametrii formali ai funcţiei apelate vor fi
iniţializaţi cu valorile parametrilor efectivi, deci cu valorile
unor adrese. Astfel, funcţia apelată poate modifica
conţinutul locaţiilor spre care pointează argumentele
(pointerii).

FUNCTII 17
Transferul parametrilor prin pointeri

FUNCTII 18
Transferul parametrilor prin pointeri

FUNCTII 19
Transferul parametrilor prin pointeri

FUNCTII 20
O functie poate returna un pointer!!!

FUNCTII 21
Transferul parametrilor prin pointeri
 Caracteristici:
 Transferul datelor este bidirecţional, de la functia apelanta catre
cea apelata si invers; modificarile realizate in corpul functiei
apelate, indirect, prin intermediul pointerilor, se regasesc
ulterior in functia apelanta.
 Parametrii efectivi pot fi expresii (expresii cu pointeri ca
operanzi) sau nume de variabile pointer.
 Functiile pot returna pointeri!

FUNCTII 22
Transferul parametrilor prin referinta
 Variabila referinta = sinonim (alt nume) al unei variabile existente.

FUNCTII 23
Transferul parametrilor prin referinta
 Variabila referinta = sinonim (alt nume) al unei variabile existente.

FUNCTII 24
Transferul parametrilor prin referinta
 Caracteristici:
 Parametrului formal transmis prin referinta i se asociaza
(atribui) chiar obiectul parametrului efectiv; parametrul efectiv
si cel formal sunt unul si acelasi obiect!!!
 Transferul datelor este bidirecţional, de la functia apelanta catre
cea apelata si invers; o modificare a parametrilor formali
determină modificarea parametrilor efectivi, care sunt sinonime
(au nume diferite, dar referă aceleaşi locaţii de memorie)
 Parametrii efectivi pot fi doar variabile (sinonime ale
parametrilor efectivi).
 Mod de transfer specific limbajului C++ .
 Functiile pot returna referinte!
FUNCTII 25
O functie poate returna o referinta!!!

FUNCTII 26
 Tablouri ca parametri
 În limbajul C, cazul parametrilor tablou constituie o
excepţie de la regula transferului parametrilor prin
valoare: numele tabloului este un pointer constant, care
are ca valoare adresa primului element al tablolui.
 doua modalitati:
 “tablou clasic”
 pointer (se utilizeaza “aritmetica pointerilor”)

FUNCTII 27
“Tablou” clasic

FUNCTII 28
Tablouri – aritmetica pointerilor

FUNCTII 29
FUNCTII 30
Tablouri ”clasice” bidimensionale

FUNCTII 31
Transferul param.-lor catre fnc. main
 Permite transmiterea unor informaţii (opţiuni, date iniţiale,
etc) către un program la lansarea în execuţie a acestuia -
> transmiterea unor parametri către funcţia main.
main(int <argc>,char *<argv>[ ],char *<env>[ ])
 <stdarg.h>

FUNCTII 32
Transferul param.-lor catre fnc. main

FUNCTII 33
 3. Functii cu parametri impliciti
 Parametri impliciţi = par. formali iniţializaţi.
<tip> <n_fc>(<l_p_form_nein> <par_init>=<val1>[,...] );
Exemplu:
int cmmdc(int x, int y = 1);
Apel:
int d1, d2;
d1=cmmdc(9); // x=9, y=1
d2=cmmdc(20,30); // x=20, y=30

FUNCTII 34
4. Functii cu nr. variabil de parametri
 Parametri ficsi
 Parametri variabili
 <stdarg.h>
<tip> <nume_f>(<lista-decl_p_form_ficsi>, . . . );
Exemplu:
void vârf (int n, double a, . . . );

FUNCTII 35
 5. Functii predefinite
 Bibliotecă de functii:
 fişierele header (conţine prototipurile funcţiilor,
declaraţiile de variabile);
 biblioteca (arhiva) propriu-zisă (conţine definiţii de
funcţii).
 fişiere header orientate pe anumite numite tipuri
de aplicaţii.

FUNCTII 36
Fc. matematice <math.h>, <cmath>
Functii aritmetice <stdlib.h>, <cstdlib>

 Valori absolute
int abs(int x); //<stdlib.h>
long int labs(long int x);
double fabs(double x);
Funcţii de rotunjire
double floor(double x);
double ceil(double x);
double round(double x);

FUNCTII 37
Fc. matematice <math.h>, <cmath>
Functii trigonometrice
 Funcţii trigonometrice
double sin(double x);
double cos(double x);
double tan(double x);

 Funcţii trigonometrice inverse

double asin(double x);
double acos(double x);
double atan(double x);
FUNCTII 38
Fc. matematice <math.h>, <cmath>
Functii exponentiale si logaritmice
double exp(double x);
long double exp(long double x);
double log(double x);
double log10(double x);
double pow(double b, double expon);
double sqrt(double x);
Funcţii de generare a numerelor aleatoare
int rand(void) <stdlib.h>
Generează un număr aleator în intervalul [0, RAND_MAX].

FUNCTII 39
Fc. de clasificare (testare) a
caracterelor <ctype.h>
int isalnum(int c);
int isalpha(int c);
int iscntrl(int c);
int isdigit(int c);
int isxdigit(int c);
int islower(int c);
int isupper(int c);
int ispunct(int c);
int isspace(int c);
int isprint(int c);

FUNCTII 40
Fc. de conversie
<ctype.h>
 Conversie a caracterelor
int tolower(int c);
int toupper(int c);
 Conversie sir -> numar
long int atol(const char *npr);
int atoi(const char *sir);
double atof(const char *sir);

FUNCTII 41
fc. de terminare proces (program)
<process.h>
void exit(int status);
 Termină execuţia unui program. Codul returnat de terminarea
corectă este memorat în constanta simbolică EXIT_SUCCES,
iar codul de eroare - în EXIT_FAILURE.
void abort();
 Termină forţat execuţia unui program.
int system(const char *comanda); <system.h>

FUNCTII 42
fc. de intrare/iesire <stdio.h>,
<cstdio>

int getchar(void);
int putchar(int c);
char *gets(char *sir);
int puts(const char *sir);
int printf(const char *format, ... );
int scanf(const char *format, ... );
int sprintf(char *<sir_f>, const char *f,...);
int sscanf(char *<sir_f>, const char *f,... );

FUNCTII 43
int printf(const char *<format>, ... );

 Parametrul fix al funcţiei conţine:

 Succesiuni de caractere afişate ca atare
printf("\n Buna ziua!\n\n”);
 Specificatori de format care definesc conversiile care vor
fi realizate asupra datelor de ieşire, din formatul intern,
în cel extern (de afişare)
 Parametrii variabili – expresii.

 OBS: Nr şi tipul parametrilor variabili trebuie să

corespundă specificatorului de format.

FUNCTII 44
int printf(const char *<format>, ... );

Forma gen. – specific. de format (par. fix):

%[-|c|][<sir_cif_event_pct_zec>] <1_sau_2_lit>
Literele - tipul conversiei datei afişate:
c – Afiseaza un caracter
s – Afiseaza un şir de caractere
d– Afiseaza date întregi; cele negative sunt precedate de semnul -.
o – Afiseaza date de tip int sau unsigned int în octal.
x sau X - Afiseaza date de tip int sau unsigned int în hexagesimal.
f– Afiseaza date de tip float sau double în forma:
parte_întreagă.parte_fract
e sau E - Afiseaza date de tip float sau double în forma:
parte_întreagă.parte_fractionară exponent
g sau G–
l – Precede una din literele d, o, x, X, u. La afişare se fac conversii din tipul long
sau unsigned long.
L – Precede una din literele f, e, E, g, G. La afişare se fac conversii din tipul long
double. FUNCTII 45
int scanf(const char *<format>, ... );

 Parametrul fix al funcţiei conţine:

 Specificatori de format care definesc conversiile
care vor fi realizate asupra datelor de intrare, din
formatul extern, în cel intern.
 Parametrii variabili – lista adrese variabile

 OBS: Nr şi tipul parametrilor variabili trebuie

să corespundă specificatorului de format.
FUNCTII 46
int scanf(const char *<format>, ... );

Literele - tipul conversiei datei citite:

c – Citeste un caracter
s – Citeste un şir de caractere
d– Citeste date întregi; cele negative sunt precedate de semnul -.
o – Citeste date de tip int sau unsigned int în octal.
x sau X - Citeste date de tip int sau unsigned int în hexagesimal.
f–Citeste date de tip float sau double în forma:
parte_întreagă.parte_fract
u - Citeste date de tip derivat unsigned
l – Precede una din literele d, o, x, X, u. La citire se fac conversii din tipul
long sau unsigned long.
L – Precede una din literele f, e, E, g, G. La citire se fac conversii din tipul
long double.

FUNCTII 47
Citire/scriere formatate intr-un sir de caractere

int sprintf(char *<sir_f>, const char

*<format>,...);
int sscanf(char *<sir_f>, const char
*<format>,... );

FUNCTII 48
 6. Supraincarcarea functiilor

 Supraîncărcarea funcţiilor = supraîncărcarea

numelui unei funcţii: utilizarea unor funcţii cu
acelaşi nume, care execută prelucrări diferite.
 Prototipurile unei funcţii supraîncărcate trebuie să
difere între ele prin numărul şi/sau tipul
parametrilor formali şi/sau prin tipul valorii
returnate.
 Selecţia funcţiei se realizează în momentul
compilării.
FUNCTII 49
 7. Clase de memorare

 Variabile globale = var. declarate în afara oricărei funcţii.

 Variabile locale = var. declarate în interiorul unui bloc.
 Scopul (domeniul de vizibilitate) al var. = porţiunea de
cod în care var. este accesibilă.
 Timpul de viaţă a unei variabile = timpul dintre
momentul alocarii memoriei pentru var. resp si momentul
eliberarii memoriei (“distrugerii” variabilei).
 O variabilă se caracterizează prin: nume, tip, valoare şi
clasă de memorare.
 Specificarea unei clase de memorare influenteaza domeniul
de vizibilitate si timpul de viata ale unei variabile.

FUNCTII 50
 Clase de memorare (cont)

 Domeniul de vizibilitate pentru o variabila:

 locala: blocul în care var. respectivă este definită.
 globala: ROF
 Timpul de viata pentru o var:
 locala: durata de execuţie a blocului (sau a funcţiei) în
care var. este definită.
 globala: durata de execuţie a programului.

FUNCTII 51
 Clase de memorare (cont)

 Clasa de memorare – la declararea var.

 Clase de memorare:
 auto
 register
 extern
 static

FUNCTII 52
Clase de memorare (cont)

FUNCTII 53
 8. Moduri de alocare a memoriei

 alocare statica:
 pentru instrucţiunile de control propriu-zise;
 pentru var. globale;
 pentru var. locale declarate în mod explicit static.
 alocare pe stiva programului:
 pentru variabilele locale.
 alocare dinamica (in mom. executiei):
 functii C (malloc, calloc, realloc, free) in
<alloc.h>
 operatori C++ (new, delete)

FUNCTII 54
Moduri de alocare a memoriei (cont)

FUNCTII 55
 Alocarea dinamica a memoriei (C)

void *malloc(size_t <nr_oct>);

void *calloc(size_t <nr_el>,size_t <măr_el>);
void *realloc(void *<ptr>, size_t <nr_oct>);
void free(void * <ptr>);

unsigned coreleft(void);

Exemplu:
int *p;
p=(int*)malloc(20*sizeof(int));
//p=(int*)calloc(20, sizeof(int));
// .......
free(p);
FUNCTII 56
Alocarea dinamica a memoriei (C++)

<tipd_point> = new <tipdata>;

<tipd_p> = new <tipd>(<val_iniţializare>);
<tipd_p> = new <tipd>[<nr_elem>];

delete <tipd_p>;
delete [<nr_elem>] <tipd_point>;

FUNCTII 57
 9. Functii recursive

 functie recursivă: fc se autoapelează:

 direct (în definiţia ei se face apel la ea însăşi)
 indirect (prin apelul altor funcţii).
 C/C++: mecanisme speciale care permit:
 suspendarea execuţiei unei funcţii
 salvarea datelor
 reactivarea execuţiei la momentul potrivit.
 Pentru fiecare apel al funcţiei, parametrii şi variabilele automatice se
memorează pe stivă, având valori distincte la fiecare reapelare. Orice
apel al unei funcţii conduce la o revenire în funcţia respectivă, în
punctul următor instrucţiunii de apel.
 La revenirea dintr-o funcţie, stiva este curăţată (revine la starea
dinaintea apelului).
 Ieşirea din recursivitate!!!!
FUNCTII 58
 Functii recursive (cont)

 Un exemplu de funcţie recursivă este funcţia de calcul a factorialului, definită

astfel:
 fact(n)=1, dacă n=0;
 fact(n)=n*fact(n-1), dacă n>0;

#include <iostream.h>
int fact(int n)
{if (n<0){
cout<<"Argument negativ!\n";
exit(2); }
else if (n==0) return 1;
else return n*fact(n-1); }
void main()
{int nr, f; cout<<"nr="; cin>>nr;
f=fact(nr); cout<<nr<<"!="<<f<<'\n'; }
FUNCTII 59
Functii recursive (cont)

FUNCTII 60
Ordonare prin QuickSort

FUNCTII 61
Ordonare prin QuickSort

FUNCTII 62
Ordonare prin metoda insertiei
(InsertSort)

FUNCTII 63
FUNCTII 64
FUNCTII 65
FUNCTII 66
FUNCTII 67
 10. Pointeri catre functii

 Pointerii către functii = variabile pointer care conţin adresa de

început a codului executabil al unei funcţii.
 Folositi pentru:
 Transferul ca parametru al adresei unei funcţii (exerciţiul 2);
 Apelul unei funcţii cu ajutorul unui pointer către aceasta.
<tip> (*<nume_point_fc>)(<l_decl_par_form>);
Exemplu:
int f(double u, int v);
int (*pf)(double, int);
int i, j; double d;
pf=f;
j=*pf(d, i);

FUNCTII 68
Pointeri catre functii (cont)

FUNCTII 69
Pointeri catre functii (cont)

FUNCTII 70