CKTIS / C++
Референция за препращане `F&&`
Когато `F` се извежда, `F&&` може да се свърже както с lvalue, така и с rvalue. При `f()` извикваемият обект се използва като lvalue, а `std::forward<F>(f)` го препраща като lvalue или rvalue според аргумента.
Версия: ISO C++23; implementation support may vary
Синтаксис
#include <utility>
template<class F>
void call(F&& f) {
std::forward<F>(f)();
}В template<class F> void call(F&& f) параметърът f е референция за препращане: && се прилага директно към типовия параметър F без добавени const или volatile, а F се извежда при извикването. За lvalue от тип T се извежда F = T& и след свиване на референциите f има тип T&. За rvalue от тип T се извежда F = T, затова f има тип T&&. Квалификаторите на типа на аргумента, например const, се запазват.
Самият запис && не е достатъчен. const F&&, конкретен тип като Callable&& и F&&, когато F вече е определен от специализация на шаблон на клас, не са референции за препращане.
В f() изразът f е lvalue дори когато декларираният тип на параметъра е Callable&&. std::forward<F>(f) от <utility> използва изведения F: за обекти резултатът е lvalue при аргумент lvalue и xvalue (вид rvalue) при аргумент rvalue. Това може да промени кой вариант се избира: operator()() & или operator()() &&.
Само по себе си std::forward не копира и не премества обекта, нито удължава живота му. Временният обект, свързан с референтен параметър, съществува до края на пълния израз, съдържащ извикването. След това запазената референция сочи към обект, който вече не съществува.
Примери
#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{});
}Резултат
lvalue lvalue lvalue rvalue
На всеки ред първо е резултатът от `f()`, а след него — този от `std::forward<F>(f)()`. За `callable` и двете извиквания избират `&`; за `Callable{}` първото избира `&`, а второто — `&&`. Обектът се извиква два пъти само за сравнение на двата варианта.
Свързани уроци
- C++ · Урок 24 · Напреднало · Версия: 3