Parametri transmiși prin referință

Ce este

Când transmiți un parametru prin valoare (int x), funcția primește o copie. Lucrează pe copie, iar la întoarcere copia dispare — originalul rămâne neatins.

Când transmiți un parametru prin referință (int &x), funcția NU mai primește o copie. Parametrul devine un alias: un al doilea nume pentru exact aceeași variabilă din apelant. Tot ce schimbi prin x se schimbă în original.

La ce folosește?

1. Întorci mai multe rezultate — return dă o singură valoare; cu referințe „scrii înapoi" în mai multe variabile deodată.
2. Eviți copierea structurilor mari — un vector cu un milion de elemente, copiat la fiecare apel, e lent; o referință e doar un alias, deci legarea e instantanee.

Cum arată

Hai să urmărim funcția care interschimbă două valori:

void interschimba(int &a, int &b) {
    int aux = a;
    a = b;
    b = aux;
}

În apelant avem x = 3 și y = 7 și chemăm interschimba(x, y). Pentru că parametrii sunt referințe, a este alt nume pentru x, iar b este alt nume pentru y. Tot ce face funcția se întâmplă, de fapt, pe x și y.

Observă esențialul: funcția nu a întors nimic cu return, dar x și y din apelant s-au modificat. Asta este puterea referinței — efectul rămâne după ce funcția se termină.

Implementare C++

Program complet care arată și interschimbarea, și întoarcerea a două rezultate prin referință:

#include <iostream>
using namespace std;

// a si b sunt referinte: alias-uri pentru variabilele din apelant
void interschimba(int &a, int &b) {
    int aux = a;       // salvam valoarea lui a
    a = b;             // a (deci x in apelant) ia valoarea lui b
    b = aux;           // b (deci y in apelant) ia vechea valoare a lui a
}

// intoarcem DOUA rezultate: scriem direct in cat si rest
void impartire(int deimpartit, int impartitor, int &cat, int &rest) {
    cat = deimpartit / impartitor;
    rest = deimpartit % impartitor;
}

int main() {
    int x = 3, y = 7;
    cout << "Inainte: x = " << x << ", y = " << y << "\n";   // 3, 7

    interschimba(x, y);   // trimitem variabilele, nu valori
    cout << "Dupa:    x = " << x << ", y = " << y << "\n";   // 7, 3

    int c, r;
    impartire(17, 5, c, r);   // c si r se umplu in interiorul functiei
    cout << "17 / 5 = " << c << " rest " << r << "\n";       // 3 rest 2

    return 0;
}

Observă apelul interschimba(x, y): trimiți variabilele x și y, nu doar niște numere. Funcția se leagă de ele și le modifică. La fel la impartire: nu folosești niciun return, dar după apel c și r conțin câtul și restul, fiindcă funcția le-a scris direct.