# Transmiterea parametrilor: valoare vs referință

> Pagina: https://bacalaurescu.ro/informatica/lectii/functii/parametri-valoare-si-referinta
> Markdown: https://bacalaurescu.ro/informatica/lectii/functii/parametri-valoare-si-referinta.md
> Sursa: Bacalaurescu (bacalaurescu.ro), conținut gratuit pentru BAC 2027.

Materia: [Informatică](https://bacalaurescu.ro/informatica)

Capitolul: [Funcții (subprograme)](https://bacalaurescu.ro/informatica/lectii/functii)
Actualizat: 2026-11-01

Diferența esențială dintre parametrii transmiși prin valoare și prin referință, cu exemple de urmărire.

## Pe scurt pentru BAC

- Modificările făcute în funcție asupra unui parametru prin valoare nu afectează originalul, iar cele prin referință rămân după apel.
- Referința se folosește când funcția trebuie să modifice argumentul sau când vrei să „returnezi” mai multe valori.
- La urmărire notezi pentru fiecare parametru dacă e valoare sau referință, apoi urmărești doar referințele înapoi în `main`.
- În `f(int x, int &y)`, ambii parametri cresc cu 10, dar după apelul `f(a, b)` cu valori 1, `a` rămâne 1, iar `b` devine 11.

## Cele două moduri de transmitere

**Prin VALOARE** (implicit): funcția primește o COPIE; modificările din funcție NU afectează variabila originală.

**Prin REFERINȚĂ** (cu `&`): funcția lucrează direct pe variabila originală; modificările RĂMÂN după apel.

## Exemplul care lămurește tot

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

Afișează: `1 11`. Explicație: `x` e copie a lui `a` (a rămâne 1), dar `y` e REFERINȚĂ la `b` (b devine 11).

## Când folosești referința

1. când funcția trebuie să MODIFICE argumentul (interschimbare, citire în funcție);
2. când vrei să "returnezi" mai multe valori dintr-o funcție.

**Interschimbarea clasică (swap):**

```cpp
void schimba(int &a, int &b) {
    int aux = a;
    a = b;
    b = aux;
}
```

Fără `&`, funcția ar interschimba doar copiile: variabilele reale ar rămâne neschimbate. E cea mai frecventă capcană de subiect II.

## Urmărirea la BAC (subiectul II)

La "ce afișează programul", notează pentru FIECARE parametru: valoare (copie, moare la final) sau referință (alias, modifică originalul). Apoi urmărește doar referințele înapoi în main.

> [!ATENTIE]
> Vectorii se transmit implicit prin ADRESĂ: modificarea elementelor v[i] în funcție se vede în main chiar FĂRĂ &. Alt comportament decât la variabilele simple.

> [!RETINE]
> Valoare înseamnă copie, referință (`&`) înseamnă aceeași variabilă. Pentru `void f(int x, int &y)` apelată cu `f(a, b)`, doar `b` poate fi modificat. Vectorii se transmit prin adresă: modificarea lui `v[i]` în funcție se vede în `main` și fără `&`.

## Greșeli frecvente

1. Lipsa lui & la swap = funcție inutilă (schimbă copii).
2. Referința cere o VARIABILĂ la apel: f(5) nu compilează dacă parametrul e int&.
3. Nu confunda & din declarația parametrului (referință) cu & operatorul de adresă.