WissensdatenbankPrüfungszentrum
DEDeutsch
Sprache wählen13

CKTIS / C++

Weiterleitungsreferenz T&&

Eine Weiterleitungsreferenz T&& ermöglicht es einem Template, lvalues und rvalues anzunehmen und dabei die für die Weiterleitung des Arguments nötigen Informationen zu erhalten. Sie setzt den passenden Deduktionskontext voraus; && allein genügt nicht.

Version: C++23; repository compiler flag, production runtime not attested

Syntax

template<class T>
void relay(T&& value);

In template<class T> void relay(T&& value); ist der Parameter T&& eine Weiterleitungsreferenz (Forwarding reference T&&): Er bezieht sich auf einen Templateparameter ohne hinzugefügte const- oder volatile-Qualifizierer. Wird T aus dem Aufrufargument deduziert, verarbeitet der Mechanismus sowohl lvalues als auch rvalues.

Bei einem lvalue vom Typ int ergibt die Deduktion T = int&; durch Referenzkollaps wird T&& zu int&. Bei einem lvalue vom Typ const int lautet das Ergebnis T = const int& und der Parametertyp ist const int&. Bei einem rvalue vom Typ int erhalten wir T = int und einen Parameter vom Typ int&&. Beim Referenzkollaps ergibt ein vorhandenes & stets &; nur die Kombination zweier && ergibt &&.

Nicht jedes && bezeichnet eine Weiterleitungsreferenz: const T&& und int&& sind keine. In template<class T> struct Box { void set(T&&); }; ist auch der Parameter von set keine: T stammt aus dem Klassentemplate und wird nicht beim Aufruf von set deduziert. Bei der Klassentemplate-Argumentdeduktion gilt eine Ausnahme für Parameter dieses Templates. Auch die explizite Angabe relay<int>(x) umgeht die Deduktion von T und erlaubt nicht, den lvalue x an int&& zu binden.

Im Beispiel ist der Ausdruck value ein lvalue, selbst wenn der Parametertyp int&& lautet. std::forward<T>(value) leitet einen lvalue als lvalue und einen rvalue als xvalue weiter und erhält dabei die Typqualifizierer. Ein einfaches inspect(value) würde selbst nach relay(42) eine lvalue-Überladung wählen. std::move(value) wandelt den Ausdruck bedingungslos in ein xvalue um und ersetzt daher keine korrekte Weiterleitung. Die Weiterleitung verlängert nicht automatisch die Lebensdauer eines Objekts; speichere keine Referenz auf ein temporäres Objekt über dessen Lebensdauer hinaus.

Beispiele

#include <iostream>
#include <utility>

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

template<class T>
void relay(T&& value) {
    inspect(std::forward<T>(value));
}

int main() {
    int x = 7;
    const int cx = 9;
    relay(x);
    relay(cx);
    relay(42);
}

Ergebnis

lvalue
const lvalue
rvalue

Der angezeigte Code und das angegebene Ergebnis wurden in einer isolierten Umgebung mit der im Prüfnachweis für genau diese Version dokumentierten Methode verifiziert.

Quellen