CKTIS / C++
A referência de encaminhamento `F&&`
Quando `F` é deduzido, `F&&` pode ligar-se a um lvalue ou a um rvalue. `f()` trata o objeto invocável como lvalue; `std::forward<F>(f)` encaminha-o como lvalue ou rvalue, consoante o argumento.
Versão: ISO C++23; implementation support may vary
Sintaxe
#include <utility>
template<class F>
void call(F&& f) {
std::forward<F>(f)();
}Em template<class F> void call(F&& f), f é uma referência de encaminhamento: && aplica-se diretamente ao parâmetro de tipo F, sem acrescentar const nem volatile, e F é deduzido na chamada. Para um lvalue de tipo T, deduz-se F = T& e o colapso de referências dá a f o tipo T&. Para um rvalue de tipo T, deduz-se F = T, pelo que f tem o tipo T&&. Os qualificadores do tipo do argumento, como const, mantêm-se.
A presença de && não basta. const F&&, um tipo concreto como Callable&& e F&& quando F já está fixado por uma especialização do modelo de classe não são referências de encaminhamento.
Em f(), a expressão f é um lvalue, mesmo que o tipo declarado do parâmetro seja Callable&&. std::forward<F>(f), de <utility>, usa o F deduzido: para objetos, produz um lvalue para um argumento lvalue e um xvalue (uma espécie de rvalue) para um argumento rvalue. Isto pode alterar a sobrecarga escolhida: operator()() & ou operator()() &&.
std::forward, por si só, não copia nem move o objeto, nem prolonga o seu tempo de vida. Um objeto temporário ligado a um parâmetro de referência dura até ao fim da expressão completa que contém a chamada. Se se guardar uma referência a esse temporário, esta fica pendente após esse ponto.
Exemplos
#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{});
}Resultado
lvalue lvalue lvalue rvalue
Cada linha mostra primeiro o resultado de `f()` e depois o de `std::forward<F>(f)()`. Para `callable`, ambas as chamadas escolhem `&`; para `Callable{}`, a primeira escolhe `&` e a segunda `&&`. O objeto só é invocado duas vezes para comparar as sobrecargas.
Lições relacionadas
- C++ · Lição 24 · Avançado · Versão: 3