Lectia nr.

8 Centru HaiLaOlimpiada Vaslui

Subprograme
O funcţie (subprogram) este un grup de instrucțiuni apelabil (invocabil) din alte părţi ale programului.
De exemplu, main este o funcţie.
A apela o funcţie înseamnă a o executa.
Funcţiile ajută la modularizarea programului, la structurarea acestuia în unităţi logice.
O funcţie se declară în felul următor:

tip nume(lista_param); // Prototipul functiei

Exemplu:

int suma(int a, int b);

lista_param - lista de parametri, despărţiţi prin virgulă, este opţională.

Parantezele sunt obligatorii. Ele deosebesc funcţiile de alte entităţi C++ (de exemplu, variabile).

void nimic(); // functie fara parametri

Tipul void reprezintă absenţa tipului. Cu alte cuvinte, funcţiile care nu returnează nicio valoare, au
tipul void.
Funcţiile pot returna valori codului apelant (locul de unde a fost apelată funcţia) prin intermediul
instrucţiunii return.
După declarare, o funcţie trebuie definită undeva în program.

#include <iostream>
using namespace std;

int suma(int, int); // Declarare

int main()
{
int x, y;
cout << "Da-mi doua numere intregi: ";
cin >> x >> y;
cout << "Suma lor este " << suma(x, y);
return 0;
}

int suma(int a, int b) // Definire

{
int rezultat = a + b;
// Puteam scrie direct
// return a + b;
return rezultat;
}

Când declarați o funcţie, puteți omite numele parametrilor (așa cum am făcut în exemplu), dar trebuie
să precizați tipul lor.
Parametrii sunt variabile locale funcţiei (vizibile numai în blocul funcţiei).
Instrucţiunea return întrerupe execuţia funcţiei şi returnează valoarea expresiei, din dreapta, codului
apelant.
Într-o funcţie puteţi avea mai multe instrucţiuni return.
Observaţi cum se apelează o funcţie: suma(x, y);. Dacă funcţia nu are parametri, se apelează doar
cu nume + paranteze: funcFaraParam();.
Când execuția unei funcții se termină, controlul programului revine în punctul apelării şi programul îşi
Lectia nr.8 Centru HaiLaOlimpiada Vaslui

continuă execuţia normal.

Funcţiile void nu returnează valori, ele doar îndeplinesc o sarcină, deci nu pot avea instrucţiunea
return expr;.
Puteţi însă folosi return; ca să întrerupeţi execuţia unei funcţii void.

#include <iostream>
using namespace std;

void afiseazaText() // Declarare + Definire

{
for (int i = 0; i < 5; i++)
cout << "Hello functions!";
}

int main()
{
// Se va afisa de 5 ori textul:
// Hello functions!
afiseazaText();
return 0;
}

Puteți declara şi defini o funcție în același loc, dar numai înainte de main, altfel compilatorul nu va
recunoaște funcția.
Funcțiile void nu pot fi folosite în expresii, deoarece expresiile au în componenta lor operatori care
așteaptă valori, ori o funcție void nu returnează nicio valoare.
O funcție poate avea orice număr de parametri.
Variabilele declarate într-o funcţie sunt locale, adică sunt vizibile numai în respectiva funcţie. Ele nu
pot fi folosite în afara ei (valabil şi pentru parametri).
Argumentele funcţiei sunt datele (variabile, expresii, constante, etc.) transmise funcţiei şi primite de
parametrii acesteia.
De exemplu, în apelul suma(x, y); argumentele sunt variabilele x şi y.

Parametrii unei funcții pot avea valori implicite (default). Parametrii default trebuie poziționați la
sfârșitul listei de parametri.
După ce ați declarat un parametru implicit, nu mai aveți voie să declarați parametri normali în
continuare acestuia, ci doar parametri impliciți.

#include <iostream>
using namespace std;

double arieCerc(double raza, double PI = 3.14)

{
return 2 * PI * raza * raza;
}

int main()
{
cout << "Aria cercului de raza 2 este " << arieCerc(2.0) << '\n'; // PI ==
3.14
cout << "Aria cercului de raza 2 este " << arieCerc(2.0, 3.141592);
return 0;
}

Se va afișa
Lectia nr.8 Centru HaiLaOlimpiada Vaslui

Aria cercului de raza 2 este 25.12

Aria cercului de raza 2 este 25.1327

Când nu transmiteți o valoare parametrului implicit, compilatorul va folosi valoarea implicită, dată de
voi.

Supraîncărcarea (Overloading) funcţiilor

Supraîncărcați o funcţie atunci când definiți mai multe versiuni ale aceleiași funcții.
Funcția trebuie să aibă același nume, dar lista de parametri trebuie să difere prin numărul parametrilor
sau prin tipul parametrilor (sau ambele).
Tipul funcției poate fi diferit, dar nu este necesar să fie aşa.
Versiunile diferă unele de altele numai prin lista de parametri!

#include <iostream>
using namespace std;

// Aria patratului
double arie(double lungime)
{
return lungime * lungime;
}

// Aria dreptunghiului
double arie(double lungime, double latime)
{
return lungime * latime;
}

int main()
{
cout << "Aria patratului de L = 2 este " << arie(2.0) << '\n';
cout << "Aria dreptunghiului de L = 3 si l = 4 este " << arie(3.0, 4.0);
return 0;
}

Output:

Aria patratului de L = 2 este 4

Aria dreptunghiului de L = 3 si l = 4 este 12

Funcţia arie este supraîncărcată (overloaded). Am două versiuni care diferă prin numărul de
parametri.
Compilatorul se foloseşte de tipul şi numărul de argumente ca să invoce funcţia corectă.

Transmiterea prin valoare şi prin referinţă

Atunci când transmiteţi argumente (şi sunt variabile) unei funcţii, transmiteţi de fapt o copie a acelor
variabile.
Aceasta este transmiterea prin valoare (pass by value).
Orice modificare a parametrilor unei funcţii este vizibilă numai în acea funcţie.
Variabilele - folosite ca argumente - rămân nemodificate.

#include <iostream>
using namespace std;
Lectia nr.8 Centru HaiLaOlimpiada Vaslui

void modifica(int a)
{
a = a + 5;
cout << "a are valoarea: " << a << '\n';
}

int main()
{
int x = 1;
cout << "x inainte de apel: " << x << '\n';
modifica(x);
cout << "x dupa apel: " << x;
return 0;
}

Output:

x inainte de apel: 1
a are valoarea: 6
x dupa apel: 1

O funcţie poate returna decât o singură valoare printr-un return, ca la matematică.

Uneori vrem ca o funcţie să poată returna mai multe valori. Un mod prin care putem obţine acest lucru
este transmiterea prin referinţă (pass by reference).
Atunci când transmiteţi prin referinţă, parametrii funcţiei alterează direct conţinutul variabilelor
argumente (nu mai există nicio copie).
Ca să transmiteţi prin referinţă folosiţi ampersand ( &) între tipul parametrului şi numele acestuia.
Parametrii referinţă acceptă numai variabile. NU acceptă constante (deoarece nu pot fi alterate)!

#include <iostream>
using namespace std;

void modifica(int& a) // Nu uitati de ampersand !

{
a = a + 5;
cout << "a are valoarea: " << a << '\n';
}

int main()
{
int x = 1;
cout << "x inainte de apel: " << x << '\n';
modifica(x);
cout << "x dupa apel: " << x;
return 0;
}

Output:

x inainte de apel: 1
a are valoarea: 6
x dupa apel: 6

Vectorii se transmit prin referinţă!

#include <iostream>
using namespace std;
Lectia nr.8 Centru HaiLaOlimpiada Vaslui

void modifica(int v[], int l)

{
for (int i = 0; i < l; i++)
v[i] += 5; // v[i] = v[i] + 5;
}

int main()
{
int w[] = {1, 2, 3, 4}, k = 4;
modifica(w, k);

for (int i = 0; i < k; i++)

cout << w[i] << ' ';

return 0;
}

Output:

6 7 8 9

Observați cum se transmite un vector ca parametru.

Numărul de elemente poate lipsi (valabil doar pentru prima dimensiune).
Dacă aș fi avut o matrice de 2 x 3, atunci aș fi scris:

void modifica(int v[][3], ...) ...

Veți înțelege mai bine aceste lucruri după ce veți învăța ceva despre pointeri.