CKTIS / C++
La referencia de reenvío `F&&`
Cuando se deduce `F`, `F&&` puede enlazarse tanto a un lvalue como a un rvalue. `f()` trata el objeto invocable como lvalue; `std::forward<F>(f)` lo reenvía como lvalue o rvalue según el argumento.
Versión: ISO C++23; implementation support may vary
Sintaxis
#include <utility>
template<class F>
void call(F&& f) {
std::forward<F>(f)();
}En template<class F> void call(F&& f), f es una referencia de reenvío: && se aplica directamente al parámetro de tipo F, sin añadir const ni volatile, y F se deduce en la llamada. Para un lvalue de tipo T, se deduce F = T& y el colapso de referencias hace que f tenga tipo T&. Para un rvalue de tipo T, se deduce F = T, por lo que f tiene tipo T&&. Se conservan los calificadores del tipo del argumento, como const.
La presencia de && no basta. No son referencias de reenvío const F&&, un tipo concreto como Callable&& ni F&& cuando una especialización de la plantilla de clase ya ha fijado F.
En f(), la expresión f es un lvalue aunque el tipo declarado del parámetro sea Callable&&. std::forward<F>(f), de <utility>, usa el F deducido: para objetos produce un lvalue si el argumento era un lvalue y un xvalue (un tipo de rvalue) si era un rvalue. Esto puede cambiar qué sobrecarga se elige: operator()() & u operator()() &&.
std::forward por sí solo no copia ni mueve el objeto ni prolonga su vida. Un objeto temporal enlazado a un parámetro por referencia vive hasta el final de la expresión completa que contiene la llamada. Cualquier referencia que se conserve a ese temporal quedará colgante después.
Ejemplos
#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 línea muestra primero el resultado de `f()` y luego el de `std::forward<F>(f)()`. Para `callable`, ambas llamadas eligen `&`; para `Callable{}`, la primera elige `&` y la segunda `&&`. Solo se invoca el objeto dos veces para comparar las sobrecargas.
Lecciones relacionadas
- C++ · Lección 24 · Avanzado · Versión: 3