Base de conocimientosCentro de exámenes
ESEspañol
Elegir idioma13

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

Fuentes