Parametri

Parametrii formali apar în definiția subprogramului, iar parametrii efectivi în apel. În Python, def dublu(x): return 2*x are parametrul formal x; în dublu(3), 3 este parametru efectiv, iar rezultatul este 6. O funcție poate primi și o listă: dacă adaugă un element la acea listă, apelantul vede schimbarea. Dacă schimbă doar valoarea unui întreg local, întregul din apelant rămâne neschimbat. În C++, această diferență se exprimă explicit prin parametru transmis prin valoare sau prin referință.

Parametrii formali apar în antetul subprogramului și sunt variabile locale ale lui; parametrii efectivi (argumentele) apar la apel și furnizează valorile sau variabilele cu care lucrează subprogramul. La apel, argumentele se asociază parametrilor în ordine, iar numărul și tipurile lor trebuie să se potrivească. Există două moduri de transmitere. Transmiterea prin valoare copiază argumentul în parametrul formal: modificările făcute în subprogram nu afectează variabila apelantului. Transmiterea prin referință (în C++, int &x) face din parametru un alt nume al variabilei transmise: modificările se văd în apelant, iar argumentul trebuie să fie o variabilă, nu o expresie. Un tablou se transmite întotdeauna prin adresă, deci subprogramul poate modifica elementele lui. În Python, funcția primește o referință la obiect: modificarea unei liste se vede în apelant, dar atribuirea unei noi valori unui întreg local nu schimbă variabila apelantului.

Exemplul 1 — valoare și referință (C++). Funcția creste primește parametrul prin referință, iar cresteCopie prin valoare:

#include <iostream>
using namespace std;
void creste(int &x) { ++x; }
void cresteCopie(int x) { ++x; }
int main() {
    int a = 4;
    cresteCopie(a);
    cout << a << ' ';
    creste(a);
    cout << a;
    return 0;
}

După cresteCopie(a) variabila a este tot 4, pentru că funcția a modificat o copie. După creste(a) variabila a este 5. Programul afișează 4 5.

Exemplul 2 — interschimbarea a două valori. Funcția void sw(int &a, int &b) schimbă valorile a două variabile ale apelantului folosind o variabilă locală ajutătoare; funcția void swv(int a, int b), cu parametri prin valoare, face aceeași operație doar pe copii. Pentru p = 3 și q = 5, după swv(p, q) variabilele rămân 3 5, iar după sw(p, q) devin 5 3. O funcție poate întoarce un singur rezultat prin return; pentru mai multe rezultate se folosesc parametri prin referință, de exemplu void minmax(int v[], int n, int &mn, int &mx), care pentru vectorul $4,1,7,3$ scrie în apelant minimul 1 și maximul 7.

Exemplul 3 — liste și numere în Python.

def adauga(v):
    v.append(1)

def creste(x):
    x += 1

v = []
a = 4
adauga(v)
creste(a)
print(v, a)

Programul afișează [1] 4. Lista v este modificată în loc, deci schimbarea se vede în apelant. În creste, instrucțiunea x += 1 creează o valoare nouă pentru x local, iar variabila a din apelant rămâne 4.

Exemplul 4 — tablou ca parametru. Procedura void adauga(int v[], int n) mărește cu 1 fiecare dintre cele n elemente. După apelul adauga(arr, 4) pentru vectorul $4,1,7,3$, vectorul apelantului devine $5,2,8,4$: parametrul v primește adresa tabloului, nu o copie a lui, deci modificările se văd în main. De aceea dimensiunea n se transmite separat, iar subprogramul nu o poate afla din tablou. Dacă procedura nu trebuie să modifice tabloul, parametrul poate fi declarat const int v[], iar orice încercare de modificare devine eroare de compilare.

Exemplul 5 — mai multe rezultate prin parametri prin referință. Subprogramul cifre calculează suma și produsul cifrelor unui număr. Numărul n se transmite prin valoare, pentru că apelantul își păstrează valoarea, iar rezultatele s și p prin referință:

void cifre(int n, int &s, int &p) {
    s = 0;
    p = 1;
    while (n > 0) {
        s += n % 10;
        p *= n % 10;
        n /= 10;
    }
}

La apelul cifre(234, s, p) ciclul parcurge cifrele 4, 3 și 2. După fiecare pas perechea $(s;p)$ este $(4;4)$, $(7;12)$ și $(9;24)$. În apelant s devine 9, iar p devine 24. Modificarea lui n în subprogram, până la 0, nu se vede în apelant, fiindcă n este o copie. Pentru n se poate transmite și o expresie, de exemplu cifre(200 + 34, s, p), dar pentru s și p nu: ele cer variabile.

Desenează separat starea apelantului și a fiecărui apel. Dacă un parametru prin valoare primește 4 și devine 5 local, argumentul rămâne 4. Dacă doi parametri prin referință primesc aceeași variabilă, modificările lor interacționează; urmărește instrucțiunile în ordine. Un tablou transmis ca parametru nu se copiază: o atribuire v[0] = 9 în subprogram schimbă tabloul apelantului, chiar dacă parametrul nu are &. Când se cere valoarea unei variabile după un apel, verifică ordinea parametrilor în antet și în apel: f(x, y) asociază x primului parametru și y celui de-al doilea, nu după nume.

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

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

• a) 11
• b) 12
• c) 21
• d) 22

Răspunsul corect este b). Parametrul a este transmis prin valoare: incrementarea lui modifică doar copia locală, iar x rămâne 1. Parametrul b este transmis prin referință și este alt nume pentru y, deci b++ face ca y să devină 2. Se afișează x, apoi y, adică 12. Varianta d) ar fi corectă dacă ambii parametri ar fi transmiși prin referință, iar varianta a) dacă niciunul nu ar fi.

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 &a, int b) { b = b + a; a = b * 2; }
int main() {
    int x = 2, y = 3;
    g(x, y);
    cout << x << ' ' << y;
    return 0;
}

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

Răspunsul corect este a). Parametrul a este alt nume pentru x, iar b este o copie a lui y. Prima instrucțiune face b = 3 + 2 = 5, numai în copie. A doua face a = 5 * 2 = 10, deci x devine 10. Variabila y rămâne 3. Varianta b) presupune greșit că și y s-a schimbat.

Greșeli frecvente

• Greșit: un parametru transmis prin valoare modifică variabila apelantului.
  Corect: subprogramul lucrează cu o copie.
• Greșit: un parametru prin referință poate primi o constantă sau o expresie.
  Corect: argumentul trebuie să fie o variabilă care poate fi modificată.
• Greșit: un tablou transmis unui subprogram C++ se copiază.
  Corect: se transmite adresa lui, iar modificările elementelor se văd în apelant.

Înainte și după