Wer ist wer in C++: lvalue, rvalue, xvalue und andere «Werte»

Was verbirgt sich hinter den Buchstaben l, r, x, gl und pr? Wir klären die Wertkategorien in C++

Wenn Sie jemals C++-Code geschrieben und einen Fehler wie "cannot bind non-const lvalue reference to an rvalue" erhalten haben, dann sind Sie dieser «Magie» bereits begegnet. Die Wertkategorien – lvalue, rvalue, xvalue, glvalue und prvalue – sind nicht nur eine akademische Klassifikation. Sie sind das Fundament, auf dem die Move-Semantik (move semantics) und die perfekte Weiterleitung (perfect forwarding) beruhen.

Lassen Sie uns ein für alle Mal klären, was jeder Buchstabe bedeutet, wie man sie in der Praxis unterscheidet und warum dieses Wissen unerlässlich ist, um modernes, effizientes C++ zu schreiben.

Kurze Geschichte: Woher kommen diese fünf Begriffe?

Ursprünglich, noch zu C-Zeiten, gab es nur zwei Konzepte: lvalue (linker Wert – das, was links von einer Zuweisung stehen kann) und rvalue (rechter Wert – das, was rechts steht). Alles war einfach: Eine Variable ist ein lvalue, eine Zahl ist ein rvalue.

Mit dem Aufkommen von C++11 und der Move-Semantik funktionierte dieses einfache Bild nicht mehr. Es entstanden rvalue-Referenzen (&&) und die Notwendigkeit, «sterbende» temporäre Objekte zu unterscheiden. So entstand die neue Klassifikation, die der C++-Standard durch fünf Kategorien beschreibt.

Werfen Sie einen Blick auf die Hierarchie (Diagramm als Text):

        expression
        /        \
   glvalue      rvalue
   /      \    /      \
lvalue   xvalue   prvalue

Merken Sie sich dieses Bild – es ist der Schlüssel zu allem.

lvalue (left value) – «langlebige» Objekte

lvalue ist ein Ausdruck, der sich auf ein Objekt bezieht, das eine Adresse im Speicher hat. Ein solches Objekt verschwindet nicht nach dem Ende des Ausdrucks. Sie können seine Adresse nehmen, es ändern, und es wird weiter existieren.

Beispiele für lvalue:

\n
• Name einer Variable: int x = 5; x ist ein lvalue.
\n
• Dereferenzierter Zeiger: *ptr.
\n
• Referenz auf eine Variable: int& ref = x; ref.
\n
• Zeichenkettenliteral: "hello" (ja, das ist ein lvalue, wenn auch ein konstantes).
\n

Code:

int main() {\n    int a = 10;\n    int* p = &a;   // Adresse nehmen – ok, a ist lvalue\n    int& ref = a;  // Referenz auf lvalue\n\n    // &(a + 1);   // Fehler! a+1 ist rvalue, keine Adresse\n    return 0;\n}

rvalue (right value) – «Einweg»-Werte

rvalue ist ein Ausdruck, der keine dauerhafte Adresse im Speicher hat. Er existiert nur im Moment der Auswertung des Ausdrucks. Sie können seine Adresse nicht nehmen (mit seltenen Ausnahmen).

Zu den rvalues gehören:

\n
• Literale (außer Zeichenketten): 42, 3.14f, true.
\n
• Ergebnisse arithmetischer Operationen: a + b.
\n
• Temporäre Objekte: std::string("temp").
\n
• Lambda-Ausdrücke.
\n

Code:

int foo() { return 5; }\n\nint main() {\n    int x = 42;       // 42 – rvalue\n    int y = x + 10;   // x+10 – rvalue\n    // int* p = &(x + 10); // Fehler! Adresse eines rvalue kann nicht genommen werden\n    return 0;\n}

prvalue (pure rvalue) – «reine» rvalues

prvalue ist das klassische rvalue aus C++98. Es ist ein temporärer Wert, der keinen Namen hat und nicht an Speicher gebunden ist. Genau dieses prvalue nennen wir umgangssprachlich meist rvalue.

Beispiele für prvalue:

\n
• Zahlen, Aufzählungen, Ergebnisse von Operatoren.
\n
• Funktionsaufruf, der eine Nicht-Referenz zurückgibt: std::to_string(123).
\n
• Explizit erstelltes temporäres Objekt: MyClass().
\n

xvalue (expiring value) – «sterbende» Objekte

Hier wird es richtig interessant. xvalue ist ein Objekt, das bald zerstört wird, dessen Ressourcen aber noch «gerettet» (verschoben) werden können. Dies ist ein