CKTIS / C++
Declarador de referencia a rvalue (`&&`)
El declarador `&&` forma un tipo de referencia a rvalue. La resolución de sobrecargas depende de la categoría de la expresión: el nombre de una variable declarada `T&&` es un lvalue cuando se usa como argumento.
Versión: ISO C++23; implementation support may vary
Sintaxis
T&& ref = expr; // local reference; requires a suitable initializer
void consume(T&& arg); // reference parameter
T&& access(); // reference return type; does not extend lifetime
using R = T&&; // reference type alias; collapsing can apply
template<class U> void relay(U&& arg); // forwarding reference when U is deducedEn T&& ref, si T es un tipo de objeto y no un tipo de referencia, && declara una referencia a rvalue. T& es una referencia a lvalue, y en const T&, const califica al objeto. No es el AND lógico incorporado a && b, que omite el operando derecho si el izquierdo es falso, ni el AND bit a bit a & b, ni la toma de dirección &x. En void f() && es un calificador de referencia de la función miembro. Las referencias a rvalue existen desde C++11; aquí se aplican las reglas de ISO C++23.
Una referencia T&& ordinaria no puede enlazarse directamente con un lvalue del mismo tipo de objeto T. Puede enlazarse con un prvalue, que materializa un objeto temporal para el enlace, o con un xvalue como std::move(x), que puede designar un objeto existente. Como argumento de llamada, el nombre ref es un lvalue aunque se declare T&&. Con las sobrecargas const int& e int&& del ejemplo, un rvalue de tipo int selecciona int&&; un lvalue de tipo int o un xvalue de tipo const int selecciona const int&.
Para un objeto, std::move, de <utility>, produce un xvalue: no quita const ni mueve nada por sí solo. Task(Task&&) y Task& operator=(Task&&) son operaciones de movimiento típicas; Task& es el tipo de retorno de la segunda. La operación puede transferir la propiedad de un recurso, como el marco de una corrutina, pero el enlace de la referencia no la transfiere. En operaciones de copia, = delete prohíbe su uso; en una operación de movimiento, = default pide la implementación que define el lenguaje, que aun así puede quedar eliminada.
Una declaración local T&& ref = T{}; prolonga la vida de ese temporal hasta que termina la vida de la referencia. Un temporal enlazado con un parámetro de referencia solo vive hasta el final de la expresión completa que contiene la llamada. Pasar la referencia a otro sitio no vuelve a prolongar su vida. No devuelvas una referencia a un objeto local que se destruye al salir de la función.
En template<class U> void relay(U&& arg), U&& es una referencia de reenvío cuando U se deduce. Para un lvalue de tipo T, se deduce U como T& y el colapso de referencias da T&; para un rvalue de tipo T, da T&&. En el colapso, cualquier & hace que el resultado sea &; solo dos && dan &&. Usa std::forward<U>(arg) de <utility> para reenviar el argumento como lvalue o rvalue según la deducción. const U&& no es una referencia de reenvío.
Ejemplos
#include <iostream>
#include <utility>
void probe(const int&) { std::cout << "const int&\n"; }
void probe(int&&) { std::cout << "int&&\n"; }
int main() {
int value = 1;
int&& ref = 2;
const int frozen = 3;
probe(value);
probe(7);
probe(ref);
probe(std::move(ref));
probe(std::move(frozen));
}
Resultado
const int& int&& const int& int&& const int&
En la llamada, `ref` es un lvalue, mientras que `std::move(ref)` es un xvalue y selecciona `int&&`. `std::move(frozen)` conserva `const`, por lo que selecciona `const int&`. El programa muestra la selección de sobrecargas, no una transferencia de recursos.
Lecciones relacionadas
- C++ · Lección 11 · Avanzado · Versión: 3
- C++ · Lección 19 · Avanzado · Versión: 3
- C++ · Lección 41 · Avanzado · Versión: 3
- C++ · Lección 42 · Avanzado · Versión: 3
- C++ · Lección 43 · Avanzado · Versión: 3
- C++ · Lección 45 · Avanzado · Versión: 3
Fuentes
- Working Draft, Standard for Programming Language C++ (N4950)
- References [dcl.ref]
- Reference initialization [dcl.init.ref]
- Value category [basic.lval]
- Temporary objects [class.temporary]
- Deducing template arguments from a function call [temp.deduct.call]
- Forward/move helpers [forward]
- Ranking implicit conversion sequences [over.ics.rank]
- Copy/move constructors [class.copy.ctor]
- Copy/move assignment operator [class.copy.assign]
- Compound expressions [expr.compound]
- Functions [dcl.fct]