WissensdatenbankPrüfungszentrum
DEDeutsch
Sprache wählen13

CKTIS / C++

Die Weiterleitungsreferenz `F&&`

Wird `F` deduziert, kann `F&&` sowohl an lvalues als auch an rvalues binden. `f()` behandelt das aufrufbare Objekt als lvalue; `std::forward<F>(f)` leitet es je nach Argument als lvalue oder rvalue weiter.

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

Syntax

#include <utility>

template<class F>
void call(F&& f) {
    std::forward<F>(f)();
}

In template<class F> void call(F&& f) ist f eine Weiterleitungsreferenz: && steht direkt beim Typparameter F, ohne zusätzliches const oder volatile, und F wird beim Aufruf deduziert. Für ein lvalue vom Typ T ergibt sich F = T&; durch Referenzkollaps hat f den Typ T&. Für ein rvalue vom Typ T ergibt sich F = T, also hat f den Typ T&&. Qualifizierer des Argumenttyps wie const bleiben erhalten.

Die Schreibweise && allein reicht nicht. const F&&, ein konkreter Typ wie Callable&& und F&& mit einem bereits durch die Klassentemplate-Spezialisierung festgelegten F sind keine Weiterleitungsreferenzen.

In f() ist der Ausdruck f ein lvalue, auch wenn der deklarierte Parametertyp Callable&& lautet. std::forward<F>(f) aus <utility> verwendet das deduzierte F: Bei Objekten ergibt sich für ein lvalue-Argument ein lvalue und für ein rvalue-Argument ein xvalue (eine Art rvalue). Dadurch kann statt operator()() & die Überladung operator()() && ausgewählt werden.

std::forward selbst kopiert oder verschiebt kein Objekt und verlängert dessen Lebensdauer nicht. Ein temporäres Objekt, das an einen Referenzparameter gebunden ist, lebt bis zum Ende des vollständigen Ausdrucks, der den Aufruf enthält. Eine aufbewahrte Referenz darauf ist danach ungültig.

Beispiele

#include <iostream>
#include <utility>

struct Callable {
    const char* operator()() & { return "lvalue"; }
    const char* operator()() && { return "rvalue"; }
};

template<class F>
void compare(F&& f) {
    const char* direct = f();
    const char* forwarded = std::forward<F>(f)();
    std::cout << direct << ' ' << forwarded << '\n';
}

int main() {
    Callable callable;
    compare(callable);
    compare(Callable{});
}

Ergebnis

lvalue lvalue
lvalue rvalue

Jede Zeile zeigt zuerst das Ergebnis von `f()` und dann das von `std::forward<F>(f)()`. Für `callable` wählen beide Aufrufe `&`; für `Callable{}` wählt der erste `&` und der zweite `&&`. Das Objekt wird nur zum Vergleich der Überladungen zweimal aufgerufen.

Zugehörige Lektionen

  • C++ · Lektion 24 · Fortgeschritten · Version: 3

Quellen