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

CKTIS / C++

Referencia a rvalue: T&&

T&& declara una referencia a rvalue, un tipo distinto de T&. Se vincula a las rvalues adecuadas y participa en la semántica de movimiento. El nombre de una referencia, usado como expresión, es normalmente una lvalue. Sin embargo, en C++23 un nombre que admite el movimiento implícito es una xvalue. Es el caso, por ejemplo, cuando el nombre de un parámetro se usa directamente como operando de una sentencia return y el parámetro es una referencia a rvalue de un tipo de objeto sin el calificador volatile. T&& con un parámetro de plantilla deducido puede ser una referencia de reenvío.

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

Sintaxis

T&& name = expression;
void consume(T&& value);
template<class T> void relay(T&& value);

Para un tipo de objeto T fijo que no sea una referencia, T&& denota una referencia a rvalue; T& denota el tipo distinto de referencia a lvalue. Por ejemplo, int&& r = 7; vincula r a un objeto temporal. Un int&& no puede vincularse directamente a una lvalue de tipo int. Una definición local de referencia requiere inicialización. Una asignación posterior cambia el objeto referido, no el objeto al que se refiere la referencia.

El tipo de una declaración y la categoría de valor de una expresión son cosas diferentes. En el ejemplo, r tiene el tipo declarado int&&, pero la expresión r es una lvalue. Por eso, inspect(r) selecciona int&, mientras que inspect(std::move(r)) selecciona int&&. std::move presenta una expresión como xvalue; no transfiere recursos por sí mismo. Un constructor o un operador de asignación seleccionado después puede realizar el movimiento.

No todo T&& es un parámetro ordinario que solo acepta rvalues. En template<class T> void relay(T&& value);, cuando T se deduce a partir del argumento de la llamada, se trata de una referencia de reenvío: acepta lvalues y rvalues. Para un argumento lvalue de tipo int, T se deduce como int&, y el colapso de referencias produce int&. La regla es: solo && combinado con && da &&; las demás combinaciones dan &. Un parámetro const T&& no es una referencia de reenvío. Para reenviar, se usa std::forward<T>(value).

Una referencia no garantiza que su objeto siga existiendo. Vincular directamente un objeto temporal en int&& r = 7; prolonga su duración hasta el final de la vida de la referencia local. Sin embargo, un temporal vinculado a un parámetro de referencia solo dura hasta el final de la expresión completa que contiene la llamada. Conservar esa referencia no prolonga de nuevo la vida del objeto y puede dejar una referencia colgante.

Ejemplos

#include <iostream>
#include <utility>

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

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

int main() {
    int&& r = 7;
    inspect(r);
    inspect(std::move(r));
    inspect(9);
    r = 12;
    std::cout << r << '\n';
}

Resultado

lvalue
rvalue
rvalue
12

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