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

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 deduced

En 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