Baza wiedzyCentrum egzaminacyjne
PLPolski
Wybierz język13

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

Źródła