¿Qué significa T&& (doble signo) en C++ 11?

Declara una referencia de valor (documento de propuesta de estándares).

Aquí hay una introducción a las referencias de rvalue .

Aquí hay una fantástica mirada en profundidad a las referencias de rvalue realizada por uno de los desarrolladores de bibliotecas estándar de Microsoft .

PRECAUCIÓN: el artículo vinculado en MSDN ("Referencias de Rvalue: Características de C++0x en VC10, Parte 2") es una introducción muy clara a las referencias de Rvalue, pero hace declaraciones sobre las referencias de Rvalue que alguna vez fueron ciertas en el borrador de C++11. estándar, ¡pero no son válidos para el final! Específicamente, dice en varios puntos que las referencias de rvalue pueden vincularse a lvalues, lo que alguna vez fue cierto, pero se cambió (por ejemplo, int x; int &&rrx = x; ya no se compila en GCC).

La mayor diferencia entre una referencia de C++ 03 (ahora llamada referencia de valor l en C++ 11) es que puede vincularse a un valor r como temporal sin tener que ser constante. Por tanto, esta sintaxis ahora es legal:

T&& r = T();

Las referencias de rvalue proporcionan principalmente lo siguiente:

Mover semántica . Ahora se puede definir un constructor de movimiento y un operador de asignación de movimiento que tome una referencia de valor r en lugar de la referencia de valor constante habitual. Una mudanza funciona como una copia, excepto que no está obligada a mantener la fuente sin cambios; de hecho, normalmente modifica la fuente de modo que ya no posee los recursos movidos. Esto es excelente para eliminar copias superfluas, especialmente en implementaciones de bibliotecas estándar.

Por ejemplo, un constructor de copias podría verse así:

foo(foo const& other)
{
    this->length = other.length;
    this->ptr = new int[other.length];
    copy(other.ptr, other.ptr + other.length, this->ptr);
}

Si a este constructor se le pasara un temporal, la copia sería innecesaria porque sabemos que el temporal simplemente será destruido; ¿Por qué no aprovechar los recursos que el temporal ya le ha asignado? En C++03, no hay forma de evitar la copia ya que no podemos determinar si se nos pasó un archivo temporal. En C++11, podemos sobrecargar un constructor de movimientos:

foo(foo&& other)
{
   this->length = other.length;
   this->ptr = other.ptr;
   other.length = 0;
   other.ptr = nullptr;
}

Observe la gran diferencia aquí: el constructor de movimientos en realidad modifica su argumento. Esto efectivamente "movería" el temporal al objeto que se está construyendo, eliminando así la copia innecesaria.

El constructor de movimiento se usaría para temporales y para referencias de valor l no constantes que se convierten explícitamente en referencias de valor r mediante la std::movefunción (solo realiza la conversión). El siguiente código invoca el constructor de movimiento for f1y f2:

foo f1((foo())); // Move a temporary into f1; temporary becomes "empty"
foo f2 = std::move(f1); // Move f1 into f2; f1 is now "empty"

Reenvío perfecto . Las referencias de rvalue nos permiten reenviar correctamente argumentos para funciones con plantilla. Tomemos, por ejemplo, esta función de fábrica:

template <typename T, typename A1>
std::unique_ptr<T> factory(A1& a1)
{
    return std::unique_ptr<T>(new T(a1));
}

Si llamamos a factory<foo>(5), se deducirá que el argumento es int&, lo que no se vinculará a un literal 5, incluso si fooel constructor de toma un int. Bueno, en su lugar podríamos usar A1 const&, pero ¿qué pasa si footoma el argumento del constructor mediante una referencia no constante? Para crear una función de fábrica verdaderamente genérica, tendríamos que sobrecargar la fábrica una A1&y otra vez A1 const&. Eso podría estar bien si la fábrica toma 1 tipo de parámetro, pero cada tipo de parámetro adicional multiplicaría la sobrecarga necesaria establecida por 2. Eso es muy rápidamente imposible de mantener.

Las referencias de rvalue solucionan este problema al permitir que la biblioteca estándar defina una std::forwardfunción que pueda reenviar correctamente referencias de lvalue/rvalue. Para obtener más información sobre cómo std::forwardfunciona, consulte esta excelente respuesta .

Esto nos permite definir la función de fábrica de esta manera:

template <typename T, typename A1>
std::unique_ptr<T> factory(A1&& a1)
{
    return std::unique_ptr<T>(new T(std::forward<A1>(a1)));
}

Ahora el valor rvalue/lvalue del argumento se conserva cuando se pasa al Tconstructor. Eso significa que si se llama a la fábrica con un valor r, Tse llama al constructor de con un valor r. Si se llama a la fábrica con un valor l, Tse llama al constructor de con un valor l. La función de fábrica mejorada funciona gracias a una regla especial:

Cuando el tipo de parámetro de función tiene la forma T&&donde Tes un parámetro de plantilla y el argumento de función es un valor l de tipo A, el tipo A&se utiliza para la deducción de argumentos de plantilla.

Por lo tanto, podemos usar factory así:

auto p1 = factory<foo>(foo()); // calls foo(foo&&)
auto p2 = factory<foo>(*p1);   // calls foo(foo const&)

Propiedades importantes de referencia de rvalue :

• Para la resolución de sobrecarga, lvalues ​​prefiere vincularse a referencias de lvalue y rvalues ​​prefiere vincularse a referencias de rvalue . De ahí por qué los temporales prefieren invocar un constructor de movimiento/operador de asignación de movimiento en lugar de un constructor de copia/operador de asignación.
• Las referencias de rvalue se vincularán implícitamente a rvalues ​​y a temporales que sean el resultado de una conversión implícita . ie float f = 0f; int&& i = f;está bien formado porque float es implícitamente convertible a int; la referencia sería a un temporal que es el resultado de la conversión.
• Las referencias de rvalue con nombre son lvalues. Las referencias de rvalue sin nombre son rvalues. Esto es importante para entender por qué la std::movellamada es necesaria en:foo&& r = foo(); foo f = std::move(r);

Mar 30 '2011 03:03 Peter Huene