C++-Referenzen: Übergabe per Referenz, const& und Aliase

Ein anderer Name für dieselbe Sache

Auf der Seite zu den Funktionsparametern wurde jedes Argument in die Funktion kopiert. Diese Kopie ist der Grund, warum eine Funktion die Variable des Aufrufers nicht ändern kann – sie sieht stets nur ihr eigenes Duplikat. Eine Referenz durchbricht diese Mauer. Sie ist ein Alias: ein zweiter Name, der an eine bestehende Variable gebunden ist und genau denselben Speicher teilt.

Du erzeugst eine Referenz mit & in der Deklaration. Einmal gebunden, sind Referenz und Original nicht mehr zu unterscheiden:

#include <iostream>
using namespace std;

int main() {
    int score = 10;
    int& alias = score;   // alias ist ein anderer Name für score

    alias = 99;           // schreibt direkt in score
    cout << score << "\n"; // 99
    cout << alias << "\n"; // 99

    score = 5;
    cout << alias << "\n"; // 5 - sie sind dasselbe Objekt
}

Zwei Regeln machen Referenzen sicher und vorhersehbar: Eine Referenz muss initialisiert werden, sobald sie deklariert wird (int& r; ist ein Compilerfehler), und sie kann danach nie umgehängt werden, um auf etwas anderes zu zeigen. Einer Referenz etwas zuzuweisen schreibt immer in das, woran sie ursprünglich gebunden wurde.

Übergabe per Referenz: lass eine Funktion zurückgreifen

Der eigentliche Gewinn liegt in den Funktionen. Setze & an einen Parameter, und die Funktion erhält statt einer Kopie einen Alias auf das Argument des Aufrufers. Jetzt sind Änderungen innerhalb der Funktion auch außerhalb sichtbar:

#include <iostream>
using namespace std;

void addBonus(int& points) {   // & bedeutet "die Variable des Aufrufers, keine Kopie"
    points += 50;
}

int main() {
    int total = 100;
    addBonus(total);
    cout << total << "\n";   // 150 - das Original wurde geändert
}

Lass das & weg, und addBonus würde eine Wegwerfkopie erhöhen, sodass total bei 100 bliebe. Dieses eine Zeichen macht den ganzen Unterschied. Das ist die kanonische Art, eine Funktion zu schreiben, die mehr als ein Ergebnis zurückgibt oder ihre Eingabe an Ort und Stelle ändert. Das klassische Beispiel ist das Vertauschen zweier Variablen:

#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
}

Ohne Referenzen würde swapValues nur lokale Kopien vertauschen und x/y blieben 1 2. (Die Standardbibliothek hat bereits std::swap, aber es selbst zu schreiben zeigt genau, was ein Referenzparameter bringt.)

const-Referenzen: schnell lesen, versprechen nicht anzufassen

Die Übergabe per Referenz vermeidet ebenfalls das Kopieren – und bei einem großen Objekt kann diese Kopie teuer sein. Aber ein schlichter T&-Parameter signalisiert „ich könnte das ändern", was irreführend ist, wenn du nur lesen willst. Die Lösung ist const T&: Du bekommst die kopierfreie Geschwindigkeit einer Referenz und ein vom Compiler erzwungenes Versprechen, dass die Funktion das Argument nicht ändert.

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

// Es wird keine Kopie des Strings erstellt, und wir können ihn nicht versehentlich ändern.
void greet(const string& name) {
    cout << "Hello, " << name << "! (" << name.size() << " chars)\n";
    // name = "x";  // wäre ein Compilerfehler - name ist const
}

int main() {
    string user = "Ada Lovelace";
    greet(user);
    greet("literal works too");   // const& kann sich auch an ein Temporäres binden
}

Eine nicht-const-Referenz kann sich nur an eine veränderbare Variable binden, aber eine const-Referenz kann sich auch an Literale und temporäre Objekte binden – deshalb kompiliert greet("literal works too"). Eine praktische Faustregel für die Wahl eines Parametertyps:

void f(int x)              // billiger Typ, nur lesen -> einfach kopieren
void f(const string& s)   // schwerer Typ, nur lesen -> const-Referenz
void f(string& s)         // du willst das Objekt des Aufrufers ändern

Verwende standardmäßig const T& für jeden Klassentyp, den du nur liest (string, vector, deine eigenen Structs), und reserviere eine nicht-const-Referenz für die Fälle, in denen du wirklich zurückschreiben willst.

Eine Referenz zurückgeben

Eine Funktion kann auch eine Referenz zurückgeben und dem Aufrufer einen Alias auf etwas bereits Bestehendes übergeben. Das ist in containerartigem Code üblich – es ist das, was v[i] = 5 ermöglicht und was operator[] unter der Haube tut:

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

// Gibt einen Alias auf ein Element zurück, sodass der Aufrufer ihm etwas zuweisen kann.
int& at(vector<int>& v, size_t i) {
    return v[i];
}

int main() {
    vector<int> data = {1, 2, 3};
    at(data, 1) = 42;            // weist über die zurückgegebene Referenz zu
    cout << data[1] << "\n";     // 42
}

Da at int& zurückgibt, ist der Aufrufausdruck at(data, 1) selbst ein Lvalue, dem du etwas zuweisen kannst. Gib stattdessen ein schlichtes int zurück, und at(data, 1) = 42 würde nicht kompilieren – du würdest einer temporären Kopie etwas zuweisen.

Die große Falle: hängende Referenzen

Eine Referenz besitzt nichts; sie zeigt nur auf Speicher, der anderswo lebt. Stirbt dieser Speicher, während die Referenz noch in Gebrauch ist, hast du eine hängende Referenz, und das Lesen darüber ist undefiniertes Verhalten – es kann Müll ausgeben, abstürzen oder scheinbar funktionieren, bis es dir in der Produktion den Tag ruiniert. Der klassische Fehler ist, eine Referenz auf eine lokale Variable zurückzugeben:

int& broken() {
    int local = 42;
    return local;   // BUG: local wird zerstört, wenn broken() zurückkehrt
}                   // die zurückgegebene Referenz hängt in der Luft

int main() {
    int& r = broken();
    cout << r << "\n";   // UNDEFINIERTES VERHALTEN - liest toten Speicher
}

Die Variable local ist in dem Moment weg, in dem broken zurückkehrt, also zeigt die Referenz auf bereits freigegebenen Stack-Speicher. Gib nur eine Referenz auf etwas zurück, das den Aufruf überlebt – einen per Referenz übergebenen Parameter, ein Datenelement oder ein static. Wird der Wert innerhalb der Funktion berechnet, gib stattdessen per Wert zurück und lass den Compiler die Kopie wegoptimieren. Dieselbe Falle trifft bereichsbasierte Schleifen und jede an ein Temporäres gebundene Referenz: Halte eine Referenz niemals über die Lebensdauer des Dings hinaus, das sie benennt.

Als Nächstes: Funktionsüberladung

Referenzen geben dir einen zweiten Regler an jedem Parameter – Kopie vs. Alias, veränderbar vs. const – und dieser Regler wirkt direkt mit dem nächsten Thema zusammen. Als Nächstes erlaubt dir die Funktionsüberladung, mehrere Funktionen mit demselben Namen, aber unterschiedlichen Parameterlisten zu definieren, und der Compiler wählt die richtige aus, indem er die Argumenttypen abgleicht – einschließlich, ob sie per Wert, per Referenz oder per const-Referenz übergeben werden.