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

CKTIS / C++

Referencia de reenvío T&&

Una referencia de reenvío T&& permite que una plantilla acepte lvalues y rvalues y conserve la información necesaria para reenviar el argumento. Requiere el contexto de deducción adecuado; && por sí solo no basta.

Versión: C++23; repository compiler flag, production runtime not attested

Sintaxis

template<class T>
void relay(T&& value);

En template<class T> void relay(T&& value);, el parámetro T&& es una referencia de reenvío (Forwarding reference T&&): se refiere a un parámetro de plantilla sin calificadores const ni volatile añadidos. Cuando T se deduce a partir del argumento de la llamada, el mecanismo admite tanto lvalues como rvalues.

Para un lvalue de tipo int, la deducción produce T = int&, y el colapso de referencias convierte T&& en int&. Para un lvalue de tipo const int, el resultado es T = const int& y el parámetro es const int&. Para un rvalue de tipo int, obtenemos T = int y un parámetro int&&. En el colapso de referencias, la presencia de & produce &; solo la combinación de dos && produce &&.

No todo && denota una referencia de reenvío: const T&& e int&& no lo son. En template<class T> struct Box { void set(T&&); };, el parámetro de set tampoco lo es: T procede de la plantilla de clase, no se deduce al llamar a set. Durante la deducción de argumentos de plantilla de clase, se aplica una excepción a los parámetros de esa plantilla. Especificar explícitamente relay<int>(x) también evita deducir T y no permite enlazar el lvalue x con int&&.

En el ejemplo, la expresión value es un lvalue aunque el tipo del parámetro sea int&&. std::forward<T>(value) reenvía un lvalue como lvalue y un rvalue como xvalue, conservando los calificadores de tipo. Un inspect(value) normal seleccionaría una sobrecarga para lvalue incluso después de relay(42). std::move(value) convierte incondicionalmente la expresión en un xvalue, así que no sustituye al reenvío correcto. El reenvío no prolonga automáticamente la vida de un objeto; no conserves una referencia a un objeto temporal más allá de su vida útil.

Ejemplos

#include <iostream>
#include <utility>

void inspect(int&) { std::cout << "lvalue\n"; }
void inspect(const int&) { std::cout << "const lvalue\n"; }
void inspect(int&&) { std::cout << "rvalue\n"; }

template<class T>
void relay(T&& value) {
    inspect(std::forward<T>(value));
}

int main() {
    int x = 7;
    const int cx = 9;
    relay(x);
    relay(cx);
    relay(42);
}

Resultado

lvalue
const lvalue
rvalue

El código mostrado y el resultado declarado se verificaron en un entorno aislado mediante el método registrado en la evidencia de verificación de esta versión exacta.

Fuentes