Subprograme

Un subprogram este o parte numită a programului, apelată pentru o sarcină precisă. Poate primi date, poate întoarce un rezultat sau poate executa o acțiune, precum afișarea. Dacă o funcție calculează pătratul unui număr, aceeași funcție poate fi apelată pentru 3 și pentru 5, fără a-i rescrie instrucțiunile. Lecțiile „Parametri”, „Domeniul variabilelor”, „Funcții și proceduri” și „Recursivitate” dezvoltă aceste noțiuni.

Un subprogram este o secvență de instrucțiuni cu un nume, scrisă o singură dată și apelată ori de câte ori este nevoie. El are un antet (numele, parametrii formali și, în C++, tipul rezultatului), un corp (instrucțiunile) și este activat printr-un apel, care furnizează argumentele efective. După rolul lui, un subprogram poate întoarce o valoare (funcție) sau poate doar executa o acțiune, de exemplu afișarea unui text (procedură). Folosirea subprogramelor elimină repetarea codului, permite testarea separată a fiecărei părți și face programul principal mai ușor de citit. Fiecare apel are propriile variabile locale, create la intrare și șterse la ieșire din subprogram.

Exemplul 1 — Python. def definește subprogramul, iar return trimite valoarea către apelant:

def dublu(x):
    return 2 * x

a = dublu(3)
b = dublu(5)
print(a + b)

La primul apel, parametrul formal x primește argumentul efectiv 3 și funcția întoarce 6; la al doilea primește 5 și întoarce 10. Programul afișează 16. Un subprogram Python fără return execută instrucțiuni, iar rezultatul lui implicit este None; un astfel de apel se scrie ca instrucțiune de sine stătătoare.

Exemplul 2 — C++. Antetul precizează tipul rezultatului, numele și parametrii formali. Un subprogram void nu întoarce o valoare:

#include <iostream>
using namespace std;
int dublu(int x) { return 2 * x; }
void afiseaza(int x) { cout << x; }
int main() {
    int a = dublu(3), b = dublu(5);
    afiseaza(a + b);
    return 0;
}

Apelurile dublu furnizează 6 și 10, apoi afiseaza(16) execută afișarea; ieșirea este 16. Funcția dublu are rezultat de tip int și se poate folosi într-o expresie; afiseaza se apelează ca instrucțiune, fără atribuire. Definițiile sunt plasate înainte de main; dacă definiția urmează după main, este necesară o declarație anterioară (prototip), de exemplu int dublu(int x);, care anunță numele și tipurile.

Exemplul 3 — funcție cu rezultat logic. O funcție care decide dacă un număr este par întoarce o valoare de tip bool: bool estePar(int x) { return x % 2 == 0; }. Apelul estePar(10) are valoarea adevărat, iar estePar(7) valoarea fals; apelul poate apărea direct într-o condiție, if (estePar(n)). Dacă aceeași verificare ar fi scrisă de trei ori în program, o modificare ulterioară ar cere trei corecturi; într-un subprogram, modificarea se face o singură dată.

Exemplul 4 — aceeași funcție, mai multe apeluri. Pentru a calcula aria totală a două dreptunghiuri, de $8\times 5$ și de $3\times 4$, se scrie o singură funcție int arie(int l, int L) { return l * L; }. Apelurile arie(8, 5) și arie(3, 4) dau 40 și 12, iar arie(8, 5) + arie(3, 4) are valoarea 52. Dacă înmulțirea ar fi scrisă direct în main pentru fiecare dreptunghi, la un al treilea dreptunghi ar trebui repetat codul, în timp ce funcția se apelează încă o dată.

Exemplul 5 — un subprogram care apelează alt subprogram. Cu funcția dublu de mai sus se poate scrie int sumaDublurilor(int a, int b) { return dublu(a) + dublu(b); }. La apelul sumaDublurilor(3, 4) se execută pe rând dublu(3), care întoarce 6, și dublu(4), care întoarce 8; rezultatul este $6+8=14$. Un subprogram apelat trebuie definit sau declarat înaintea celui care îl apelează.

Exemplul 6 — variabile locale cu același nume. În programul următor, y din f și y din main sunt două variabile diferite:

#include <iostream>
using namespace std;
int f(int x) { int y = x + 1; return y; }
int main() {
    int y = 10;
    cout << f(4) << ' ' << y;
    return 0;
}

Apelul f(4) creează un y local cu valoarea 5, apoi îl șterge la ieșire. Se afișează 5 10: variabila y din main nu a fost atinsă.

Un parametru transmis prin valoare primește o copie: modificarea sa nu schimbă variabila din apelant. În C++, int &x desemnează un parametru prin referință: dacă subprogramul îi atribuie altă valoare, se modifică variabila transmisă. De exemplu, după void creste(int &x) { ++x; } și int a = 4; creste(a);, variabila a este 5. Într-un fragment cu mai multe apeluri, scrie pentru fiecare apel argumentele, valoarea întoarsă și variabilele modificate. Pentru urmărirea mai multor argumente și a efectelor lor, continuă cu lecția „Parametri”. Valoarea unei funcții se folosește numai dacă apelul o primește: apelul f(a); fără atribuire sau afișare calculează valoarea, dar o aruncă.

Exemplu în formatul examenului. Ce se afișează în urma executării programului de mai jos?

#include <iostream>
using namespace std;
int f(int x) { x = x + 2; return x * 2; }
int main() {
    int a = 3;
    int b = f(a);
    cout << a << ' ' << b;
    return 0;
}

• a) 3 10
• b) 5 10
• c) 3 6
• d) 5 5

Răspunsul corect este a). Parametrul x este transmis prin valoare, deci primește o copie a lui a. În interiorul funcției, x devine $3+2=5$, iar funcția întoarce $5\cdot 2=10$. Variabila a din main rămâne 3, iar b primește 10. Varianta b) ar fi corectă dacă x ar fi transmis prin referință, caz în care a ar deveni 5.

Al doilea exemplu în formatul examenului. Ce se afișează în urma executării programului de mai jos?

#include <iostream>
using namespace std;
void g(int &x, int y) { x = x + y; y = 0; }
int main() {
    int a = 4, b = 5;
    g(a, b);
    cout << a << ' ' << b;
    return 0;
}

• a) 9 5
• b) 9 0
• c) 4 5
• d) 4 0

Răspunsul corect este a). Parametrul x este transmis prin referință, deci este chiar variabila a: după x = x + y, valoarea lui a este $4+5=9$. Parametrul y este transmis prin valoare și primește o copie a lui b; atribuirea y = 0 schimbă doar copia, deci b rămâne 5. Varianta b) presupune că ambii parametri sunt referințe, iar varianta c) că niciunul nu este.

Greșeli frecvente

• Greșit: un subprogram trebuie să întoarcă mereu o valoare.
  Corect: un subprogram void execută o acțiune și nu întoarce nicio valoare.
• Greșit: dacă un subprogram modifică parametrul transmis prin valoare, se schimbă variabila din apelant.
  Corect: se modifică doar copia locală.
• Greșit: un subprogram C++ definit după main poate fi apelat fără nicio declarație anterioară.
  Corect: este necesar un prototip sau definiția trebuie să apară înaintea apelului.

Înainte și după