Referencje w C++: przekazywanie przez referencję, const& i aliasy

Inna nazwa tej samej rzeczy

Na stronie o parametrach funkcji każdy argument był kopiowany do funkcji. Przez tę kopię funkcja nie może zmienić zmiennej wywołującego: widzi tylko własny duplikat. Referencja burzy ten mur. To alias: druga nazwa powiązana z istniejącą zmienną, dzieląca z nią dokładnie tę samą pamięć.

Referencję tworzysz przez & w deklaracji. Po powiązaniu referencji i oryginału nie da się odróżnić:

#include <iostream>
using namespace std;

int main() {
    int score = 10;
    int& alias = score;   // alias to inna nazwa score

    alias = 99;           // zapis trafia do score
    cout << score << "\n"; // 99
    cout << alias << "\n"; // 99

    score = 5;
    cout << alias << "\n"; // 5: to ten sam obiekt
}

Dwie zasady czynią referencje bezpiecznymi i przewidywalnymi: referencja musi być zainicjalizowana w chwili deklaracji (int& r; to błąd kompilacji) i nigdy nie da się jej potem przestawić na coś innego. Przypisanie do referencji zawsze zapisuje do tego, z czym była pierwotnie powiązana.

Przekazywanie przez referencję: funkcja sięga z powrotem

Prawdziwa korzyść jest w funkcjach. Dodaj & do parametru, a funkcja dostanie alias argumentu wywołującego zamiast kopii. Zmiany wewnątrz funkcji są teraz widoczne na zewnątrz:

#include <iostream>
using namespace std;

void addBonus(int& points) {   // & znaczy "zmienna wywołującego, a nie kopia"
    points += 50;
}

int main() {
    int total = 100;
    addBonus(total);
    cout << total << "\n";   // 150: oryginał się zmienił
}

Usuń &, a addBonus zwiększy jednorazową kopię, zostawiając total na 100. Ten jeden znak stanowi całą różnicę. To kanoniczny sposób pisania funkcji, która zwraca więcej niż jeden wynik albo edytuje swoje wejście w miejscu. Klasyczny przykład to zamiana dwóch zmiennych:

#include <iostream>
using namespace std;

void swapValues(int& a, int& b) {
    int tmp = a;
    a = b;
    b = tmp;
}

int main() {
    int x = 1, y = 2;
    swapValues(x, y);
    cout << x << " " << y << "\n";   // 2 1
}

Bez referencji swapValues zamieniłoby tylko lokalne kopie, a x/y zostałyby 1 2. (Biblioteka standardowa ma już std::swap, ale samodzielne napisanie tej funkcji dokładnie pokazuje, co daje parametr referencyjny.)

Referencje const: szybki odczyt z obietnicą nietykalności

Przekazywanie przez referencję unika też kopiowania, a przy dużym obiekcie kopia może być kosztowna. Ale zwykły parametr T& sygnalizuje „mogę to zmienić”, co wprowadza w błąd, gdy chcesz tylko czytać. Rozwiązaniem jest const T&: dostajesz szybkość referencji bez kopii i wymuszaną przez kompilator obietnicę, że funkcja nie zmieni argumentu.

#include <iostream>
#include <string>
using namespace std;

// Napis nie jest kopiowany i nie możemy go przypadkiem zmienić.
void greet(const string& name) {
    cout << "Hello, " << name << "! (" << name.size() << " chars)\n";
    // name = "x";  // byłby to błąd kompilacji: name jest const
}

int main() {
    string user = "Ada Lovelace";
    greet(user);
    greet("literal works too");   // const& może też powiązać się z obiektem tymczasowym
}

Referencja nie-const może się powiązać tylko ze zmienną, którą da się modyfikować, ale referencja const może się też powiązać z literałami i obiektami tymczasowymi, dlatego greet("literal works too") się kompiluje. Praktyczna zasada wyboru typu parametru:

void f(int x)              // tani typ, tylko odczyt -> po prostu skopiuj
void f(const string& s)   // ciężki typ, tylko odczyt -> referencja const
void f(string& s)         // zamierzasz zmienić obiekt wywołującego

Domyślnie używaj const T& dla każdego typu klasowego, który tylko czytasz (string, vector, własne struktury), a referencję nie-const zostaw na sytuacje, gdy naprawdę chcesz zapisać zmiany z powrotem.

Zwracanie referencji

Funkcja może też zwracać referencję, dając wywołującemu alias do czegoś, co już istnieje. To częste w kodzie przypominającym kontenery: dzięki temu działa v[i] = 5 i tak właśnie działa pod spodem przeciążanie operatorów:

#include <iostream>
#include <vector>
using namespace std;

// Zwraca alias do elementu, więc wywołujący może do niego przypisać.
int& at(vector<int>& v, size_t i) {
    return v[i];
}

int main() {
    vector<int> data = {1, 2, 3};
    at(data, 1) = 42;            // przypisanie przez zwróconą referencję
    cout << data[1] << "\n";     // 42
}

Ponieważ at zwraca int&, samo wyrażenie wywołania at(data, 1) jest lwartością, do której można przypisać. Zwróć zamiast tego zwykły int, a at(data, 1) = 42 się nie skompiluje, bo przypisanie trafiałoby do tymczasowej kopii.

Wielka pułapka: wiszące referencje

Referencja niczego nie posiada; wskazuje tylko pamięć, która żyje gdzie indziej. Jeśli ta pamięć umrze, gdy referencja jest wciąż w użyciu, masz wiszącą referencję, a czytanie przez nią to niezdefiniowane zachowanie: może wypisać śmieci, wywołać awarię albo wyglądać na działające, dopóki nie zepsuje ci dnia na produkcji. Klasyczny błąd to zwracanie referencji do zmiennej lokalnej:

int& broken() {
    int local = 42;
    return local;   // BŁĄD: local jest niszczone, gdy broken() się kończy
}                   // zwrócona referencja wisi

int main() {
    int& r = broken();
    cout << r << "\n";   // NIEZDEFINIOWANE ZACHOWANIE: czyta martwą pamięć
}

Zmienna local znika w chwili, gdy broken się kończy, więc referencja wskazuje na odzyskane miejsce na stosie. Zwracaj referencję tylko do czegoś, co przeżyje wywołanie: parametru przekazanego przez referencję, pola obiektu albo zmiennej statycznej. Jeśli wartość jest obliczana wewnątrz funkcji, zwróć ją przez wartość i pozwól kompilatorowi zoptymalizować kopię. Ta sama pułapka dotyczy pętli po zakresie i każdej referencji powiązanej z obiektem tymczasowym: nigdy nie trzymaj referencji dłużej, niż żyje to, co nazywa.

Dalej: przeciążanie funkcji

Referencje dają ci drugie pokrętło przy każdym parametrze: kopia czy alias, modyfikowalny czy const. To pokrętło bezpośrednio łączy się z kolejnym tematem. Przeciążanie funkcji pozwala zdefiniować kilka funkcji o tej samej nazwie, ale różnych listach parametrów, a kompilator wybiera właściwą, dopasowując typy argumentów, w tym to, czy są przekazywane przez wartość, przez referencję, czy przez referencję const.