CKTIS / C++
Referencja przekazująca `F&&`
Parametr `F&&` z dedukowanym `F` może przyjąć zarówno lvalue, jak i rvalue. Samo wywołanie `f()` traktuje obiekt wywoływalny jak lvalue; `std::forward<F>(f)` przekazuje go dalej jako lvalue lub rvalue zgodnie z argumentem.
Wersja: ISO C++23; implementation support may vary
Składnia
#include <utility>
template<class F>
void call(F&& f) {
std::forward<F>(f)();
}W template<class F> void call(F&& f) parametr f jest referencją przekazującą: F&& odnosi się bezpośrednio do parametru typu F bez kwalifikatorów const i volatile, a F jest dedukowane przy wywołaniu. Dla lvalue typu T dedukowane jest F = T&, więc po złożeniu referencji f ma typ T&. Dla rvalue typu T dedukowane jest F = T, więc f ma typ T&&. Kwalifikatory typu argumentu, np. const, nie są usuwane.
Samo && nie wystarcza. const F&&, konkretny typ Callable&& oraz F&&, gdy F jest już ustalone przez instancję szablonu klasy, nie są referencjami przekazującymi.
W wywołaniu f() wyrażenie f jest lvalue, nawet gdy zadeklarowany typ parametru to Callable&&. std::forward<F>(f) z <utility> używa dedukowanego F: dla obiektów daje lvalue po przekazaniu lvalue, a xvalue (rodzaj rvalue) po przekazaniu rvalue. Może to zmienić wybór między przeciążeniami operator()() & i operator()() &&.
Samo std::forward niczego nie kopiuje, nie przenosi ani nie przedłuża czasu życia obiektu. Obiekt tymczasowy związany z parametrem referencyjnym żyje do końca pełnego wyrażenia zawierającego wywołanie. Zachowana referencja do niego będzie potem wisząca.
Przykłady
#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{});
}Wynik
lvalue lvalue lvalue rvalue
Każdy wiersz pokazuje najpierw wynik `f()`, a potem `std::forward<F>(f)()`. Dla `callable` oba wywołania wybierają `&`; dla `Callable{}` pierwsze wybiera `&`, a drugie `&&`. Przykład wywołuje obiekt dwa razy tylko po to, by porównać przeciążenia.
Powiązane lekcje
- C++ · Lekcja 24 · Zaawansowany · Wersja: 3