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.