¿Qué es “referencia de valor de * esto”?

Encontré una propuesta llamada “referencia rvalue para * esto” en la página de estado de C ++ 11 de clang.

He leído bastante sobre las referencias de valores reales y las he entendido, pero no creo que sepa nada al respecto. Tampoco pude encontrar muchos recursos en la web usando los términos.

Hay un enlace al documento de propuesta en la página: N2439 (semántica de movimiento extensible a * esto), pero tampoco obtengo muchos ejemplos a partir de ahí.

¿De qué se trata esta característica?

Primero, “ref-qualifiers para * esto” es solo una “statement de marketing”. El tipo de *this nunca cambia, mira la parte inferior de esta publicación. Sin embargo, es mucho más fácil de entender con esta fraseología.

A continuación, el siguiente código elige la función que se llamará en función del calificador ref del “parámetro de objeto implícito” de la función :

 // t.cpp #include  struct test{ void f() &{ std::cout << "lvalue object\n"; } void f() &&{ std::cout << "rvalue object\n"; } }; int main(){ test t; tf(); // lvalue test().f(); // rvalue } 

Salida:

 $ clang++ -std=c++0x -stdlib=libc++ -Wall -pedantic t.cpp $ ./a.out lvalue object rvalue object 

Todo está hecho para permitirle aprovechar el hecho de que cuando el objeto al que se llama la función es un valor r (por ejemplo, temporal sin nombre). Tome el siguiente código como un ejemplo más:

 struct test2{ std::unique_ptr heavy_resource; test2() : heavy_resource(new int[500]) {} operator std::unique_ptr() const&{ // lvalue object, deep copy std::unique_ptr p(new int[500]); for(int i=0; i < 500; ++i) p[i] = heavy_resource[i]; return p; } operator std::unique_ptr() &&{ // rvalue object // we are garbage anyways, just move resource return std::move(heavy_resource); } }; 

Esto puede ser un poco artificial, pero debes tener la idea.

Tenga en cuenta que puede combinar los calificadores cv ( const y volatile ) y los calificadores ref ( & y && ).


Nota: ¡Muchas citas estándar y explicación de resolución de sobrecarga después de aquí!

† Para comprender cómo funciona esto, y por qué la respuesta de @Nicol Bolas es, al menos en parte, incorrecta, debemos excavar un poco en el estándar C ++ (la parte que explica por qué la respuesta de @ Nicol es incorrecta está en la parte inferior, si solo interesado en eso).

La función que se va a llamar está determinada por un proceso llamado resolución de sobrecarga . Este proceso es bastante complicado, así que solo tocaremos el bit que es importante para nosotros.

En primer lugar, es importante ver cómo funciona la resolución de sobrecarga para las funciones miembro:

§13.3.1 [over.match.funcs]

p2 El conjunto de funciones candidatas puede contener funciones miembro y no miembro para ser resueltas en la misma lista de argumentos. Para que las listas de parámetros y argumentos sean comparables dentro de este conjunto heterogéneo, se considera que una función miembro tiene un parámetro extra, llamado el parámetro de objeto implícito, que representa el objeto para el que se ha llamado a la función miembro . [...]

p3 De forma similar, cuando sea apropiado, el contexto puede construir una lista de argumentos que contenga un argumento de objeto implícito para denotar el objeto para ser operado.

¿Por qué necesitamos siquiera comparar funciones de miembros y no miembros? Sobrecarga del operador, es por eso. Considera esto:

 struct foo{ foo& operator<<(void*); // implementation unimportant }; foo& operator<<(foo&, char const*); // implementation unimportant 

Seguramente querrás que lo siguiente llame a la función gratuita, ¿no?

 char const* s = "free foo!\n"; foo f; f << s; 

Es por eso que las funciones miembro y no miembro están incluidas en el llamado conjunto de sobrecarga. Para que la resolución sea menos complicada, existe la parte en negrita de la cita estándar. Además, este es un aspecto importante para nosotros (misma cláusula):

p4 Para funciones miembro no estáticas, el tipo del parámetro de objeto implícito es

  • "Lvalue reference to cv X " para las funciones declaradas sin un ref-qualifier o con el calificador & ref

  • "Referencia de rvalue a cv X " para las funciones declaradas con el calificador && ref

donde X es la clase de la cual la función es miembro y cv es la calificación cv en la statement de la función miembro. [...]

p5 Durante la resolución de sobrecarga [t ...] [t] el parámetro de objeto implícito [...] conserva su identidad ya que las conversiones en el argumento correspondiente obedecerán estas reglas adicionales:

  • no se puede introducir ningún objeto temporal para mantener el argumento para el parámetro de objeto implícito; y

  • no se pueden aplicar conversiones definidas por el usuario para lograr un tipo coincidente con él

[...]

(El último bit solo significa que no se puede engañar a la resolución de sobrecarga en función de las conversiones implícitas del objeto al que se llama una función miembro (u operador)).

Tomemos el primer ejemplo en la parte superior de esta publicación. Después de la transformación mencionada, el conjunto de sobrecarga se ve así:

 void f1(test&); // will only match lvalues, linked to 'void test::f() &' void f2(test&&); // will only match rvalues, linked to 'void test::f() &&' 

Luego, la lista de argumentos, que contiene un argumento de objeto implícito , se compara con la lista de parámetros de cada función contenida en el conjunto de sobrecarga. En nuestro caso, la lista de argumentos solo contendrá ese argumento de objeto. Veamos cómo se ve eso:

 // first call to 'f' in 'main' test t; f1(t); // 't' (lvalue) can match 'test&' (lvalue reference) // kept in overload-set f2(t); // 't' not an rvalue, can't match 'test&&' (rvalue reference) // taken out of overload-set 

Si, después de probar todas las sobrecargas en el conjunto, solo queda una, la resolución de sobrecarga tuvo éxito y se llama a la función vinculada a esa sobrecarga transformada. Lo mismo ocurre con la segunda llamada a 'f':

 // second call to 'f' in 'main' f1(test()); // 'test()' not an lvalue, can't match 'test&' (lvalue reference) // taken out of overload-set f2(test()); // 'test()' (rvalue) can match 'test&&' (rvalue reference) // kept in overload-set 

Sin embargo, tenga en cuenta que, si no hubiéramos proporcionado ningún calificador de ref (y como tal no sobrecargado la función), que f1 coincidiría con un valor de r (todavía §13.3.1 ):

p5 [...] Para las funciones miembro no estáticas declaradas sin un calificador de ref , se aplica una regla adicional:

  • incluso si el parámetro de objeto implícito no está const qualificado, se puede vincular un valor r al parámetro siempre que en todos los demás aspectos el argumento se pueda convertir al tipo del parámetro de objeto implícito.
 struct test{ void f() { std::cout << "lvalue or rvalue object\n"; } }; int main(){ test t; tf(); // OK test().f(); // OK too } 

Ahora, sobre por qué la respuesta de @ Nicol es al menos parcialmente incorrecta. Él dice:

Tenga en cuenta que esta statement cambia el tipo de *this .

Eso está mal, *this es siempre un lvalue:

§5.3.1 [expr.unary.op] p1

El operador unario * realiza indirección : la expresión a la que se aplica debe ser un puntero a un tipo de objeto, o un puntero a un tipo de función y el resultado es un valor l que se refiere al objeto o función a la que apunta la expresión.

§9.3.2 [class.this] p1

En el cuerpo de una función miembro no estática (9.3), la palabra clave this es una expresión prvalue cuyo valor es la dirección del objeto para el que se llama a la función. El tipo de this en una función miembro de una clase X es X* . [...]

Hay un caso de uso adicional para el formulario lvalue ref-calificador. C ++ 98 tiene un lenguaje que permite const funciones miembro no const para instancias de clase que son valores r. Esto lleva a todo tipo de rareza que va en contra del concepto de valor real y se desvía de la forma en que funcionan los tipos incorporados:

 struct S { S& operator ++(); S* operator &(); }; S() = S(); // rvalue as a left-hand-side of assignment! S& foo = ++S(); // oops, dangling reference &S(); // taking address of rvalue... 

Los ref-calificadores de Lvalue resuelven estos problemas:

 struct S { S& operator ++() &; S* operator &() &; const S& operator =(const S&) &; }; 

Ahora los operadores funcionan como los de los tipos integrados, y solo aceptan valores l.

Supongamos que tiene dos funciones en una clase, ambas con el mismo nombre y firma. Pero uno de ellos se declara const :

 void SomeFunc() const; void SomeFunc(); 

Si una instancia de clase no es const , la resolución de sobrecarga seleccionará preferentemente la versión no const. Si la instancia es const , el usuario solo puede llamar a la versión const . Y this puntero es un puntero de const , por lo que la instancia no se puede cambiar.

Lo que hace la “referencia de valor r para esto” es permitirle agregar otra alternativa:

 void RValueFunc() &&; 

Esto le permite tener una función que solo puede invocarse si el usuario la llama a través de un valor r adecuado. Entonces, si esto está en el tipo Object :

 Object foo; foo.RValueFunc(); //error: no `RValueFunc` version exists that takes `this` as l-value. Object().RValueFunc(); //calls the non-const, && version. 

De esta forma, puede especializar el comportamiento según si se accede al objeto a través de un valor r o no.

Tenga en cuenta que no puede sobrecargar entre las versiones de referencia de valor r y las versiones que no son de referencia. Es decir, si tiene un nombre de función miembro, todas sus versiones utilizan los calificadores l / r-value en this , o ninguna de ellas lo hace. No puedes hacer esto:

 void SomeFunc(); void SomeFunc() &&; 

Tienes que hacer esto:

 void SomeFunc() &; void SomeFunc() &&; 

Tenga en cuenta que esta statement cambia el tipo de *this . Esto significa que todas las versiones de && acceden a los miembros como referencias de valor r. Por lo tanto, es posible moverse fácilmente desde el interior del objeto. El ejemplo dado en la primera versión de la propuesta es (nota: lo siguiente puede no ser correcto con la versión final de C ++ 11; es directamente de la propuesta inicial “r-value from this”):

 class X { std::vector data_; public: // ... std::vector const & data() const & { return data_; } std::vector && data() && { return data_; } }; X f(); // ... X x; std::vector a = x.data(); // copy std::vector b = f().data(); // move