WissensdatenbankPrüfungszentrum
DEDeutsch
Sprache wählen13

CKTIS / C++

Deklarator für Rvalue-Referenzen (`&&`)

Der Deklarator `&&` bildet einen Rvalue-Referenztyp. Für die Überladungsauflösung zählt jedoch die Wertkategorie des Ausdrucks: Der Name einer als `T&&` deklarierten Variablen ist als Argument ein Lvalue.

Version: ISO C++23; implementation support may vary

Syntax

T&& ref = expr;               // local reference; requires a suitable initializer
void consume(T&& arg);        // reference parameter
T&& access();                 // reference return type; does not extend lifetime
using R = T&&;                // reference type alias; collapsing can apply
template<class U> void relay(U&& arg);  // forwarding reference when U is deduced

In T&& ref deklariert && eine Rvalue-Referenz, wenn T ein Objekttyp und kein Referenztyp ist. T& ist eine Lvalue-Referenz; in const T& qualifiziert const das Objekt. Gemeint ist weder das eingebaute logische a && b, das bei falschem linken Operanden den rechten nicht auswertet, noch das bitweise a & b oder die Adressbildung &x. In void f() && ist das Zeichen ein Ref-Qualifizierer der Memberfunktion. Rvalue-Referenzen gibt es seit C++11; hier gelten die Regeln von ISO C++23.

Eine gewöhnliche Referenz T&& kann nicht direkt an einen Lvalue desselben Objekttyps T binden. Sie kann an einen Prvalue binden, für den dabei ein temporäres Objekt materialisiert wird, oder an einen Xvalue wie std::move(x), der ein bestehendes Objekt bezeichnen kann. Als Aufrufargument ist der Name ref ein Lvalue, auch wenn er als T&& deklariert ist. Bei den Überladungen const int& und int&& im Beispiel wählt ein Rvalue vom Typ int die Überladung int&&; ein Lvalue vom Typ int oder ein Xvalue vom Typ const int wählt const int&.

std::move aus <utility> liefert für ein Objekt einen Xvalue: Es entfernt weder const noch verschiebt es selbst etwas. Task(Task&&) und Task& operator=(Task&&) sind typische Verschiebeoperationen; Task& ist in der zweiten Deklaration der Rückgabetyp. Die Operation kann den Besitz einer Ressource wie eines Koroutinen-Frames übertragen; die Referenzbindung tut das nicht. = delete bei Kopieroperationen verbietet deren Verwendung. = default bei einer Verschiebeoperation fordert die vom Sprachstandard vorgesehene Implementierung an, die trotzdem gelöscht sein kann.

Eine lokale Deklaration T&& ref = T{}; verlängert die Lebensdauer dieses temporären Objekts auf die Lebensdauer der Referenz. Ein an einen Referenzparameter gebundenes temporäres Objekt lebt nur bis zum Ende des vollständigen Ausdrucks, der den Aufruf enthält. Weiterreichen der Referenz verlängert die Lebensdauer nicht erneut. Gib keine Referenz auf ein lokales Objekt zurück, das beim Verlassen der Funktion zerstört wird.

In template<class U> void relay(U&& arg) ist U&& bei deduziertem U eine Weiterleitungsreferenz. Für einen Lvalue vom Typ T wird U als T& deduziert, und durch Referenzkollaps entsteht T&; für einen Rvalue vom Typ T entsteht T&&. Beim Kollaps setzt sich jedes & durch; nur zwei && ergeben &&. Verwende std::forward<U>(arg) aus <utility>, um das Argument entsprechend der Deduktion als Lvalue oder Rvalue weiterzugeben. const U&& ist keine Weiterleitungsreferenz.

Beispiele

#include <iostream>
#include <utility>

void probe(const int&) { std::cout << "const int&\n"; }
void probe(int&&)      { std::cout << "int&&\n"; }

int main() {
    int value = 1;
    int&& ref = 2;
    const int frozen = 3;

    probe(value);
    probe(7);
    probe(ref);
    probe(std::move(ref));
    probe(std::move(frozen));
}

Ergebnis

const int&
int&&
const int&
int&&
const int&

Im Aufruf ist `ref` ein Lvalue; `std::move(ref)` ist ein Xvalue und wählt `int&&`. `std::move(frozen)` behält `const` bei und wählt daher `const int&`. Das Programm zeigt die Überladungsauflösung, nicht die Übertragung von Ressourcen.

Zugehörige Lektionen

  • C++ · Lektion 11 · Fortgeschritten · Version: 3
  • C++ · Lektion 19 · Fortgeschritten · Version: 3
  • C++ · Lektion 41 · Fortgeschritten · Version: 3
  • C++ · Lektion 42 · Fortgeschritten · Version: 3
  • C++ · Lektion 43 · Fortgeschritten · Version: 3
  • C++ · Lektion 45 · Fortgeschritten · Version: 3

Quellen