Qu'est-ce que "rvalue reference for * this"?

Première, "ref-qualificatifs pour *ce" est un juste un "marketing de l'instruction". Le type de *this ne change jamais, voir en bas de ce post. C'est beaucoup plus facile à comprendre avec ce libellé.

Ensuite, le code suivant permet de choisir la fonction à être appelés en fonction de la ref-qualificatif de la "implicite paramètre de l'objet" de la fonction^†:

//t.cpp
#include <iostream>

struct test{
  void f() &{ std::cout << "lvalue object\n"; }
  void f() &&{ std::cout << "rvalue object\n"; }
};

int main(){
  test t;
  t.f(); //lvalue
  test().f(); //rvalue
}

De sortie:

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

Le tout est fait pour vous permettre de profiter du fait que lorsque l'objet de l'appel de la fonction est une rvalue (sans nom temporaire, par exemple). Prenez le code suivant comme un autre exemple:

struct test2{
  std::unique_ptr<int[]> heavy_resource;

  test2()
    : heavy_resource(new int[500]) {}

  operator std::unique_ptr<int[]>() const&{
    //lvalue object, deep copy
    std::unique_ptr<int[]> p(new int[500]);
    for(int i=0; i < 500; ++i)
      p[i] = heavy_resource[i];

    return p;
  }

  operator std::unique_ptr<int[]>() &&{
    //rvalue object
    //we are garbage anyways, just move resource
    return std::move(heavy_resource);
  }
};

Cela peut être un peu tiré par les cheveux, mais vous devriez obtenir l'idée.

Notez que vous pouvez combiner le cv-qualificatifs (const et volatile) et ref-qualificatifs (& et &&).

---

^{Remarque: Beaucoup de citations et de résolution de surcharge explication après ici!}

† Pour comprendre comment cela fonctionne, et pourquoi @Nicol Bolas réponse est au moins en partie tort, nous devons creuser dans la norme C++ pour un peu (la partie expliquant pourquoi @Nicol la réponse est fausse est en bas, si vous n'êtes intéressé que par que).

La fonction qui va être appelée est déterminée par un processus appelé résolution de surcharge. Ce processus est assez complexe, nous allons donc nous toucher le peu qui est important pour nous.

Tout d'abord, il est important de voir comment la résolution de surcharge pour les fonctions de membre de travaux:

§13.3.1 [over.match.funcs]

p2 L'ensemble des fonctions candidates peuvent contenir à la fois membre et non-membre de fonctions pour être résolues par rapport à la même liste d'arguments. Pour que l'argument et listes de paramètres sont comparables au sein de cet ensemble hétérogène, une fonction membre est considéré comme un paramètre supplémentaire, appelé l'implicite paramètre de l'objet, qui représente l'objet pour lequel la fonction de membre a été appelé. [...]

p3 de Même, le cas échéant, le contexte peut construire une liste d'arguments qui contient un implicite de l'objet argument pour désigner l'objet doit être opéré.

Pourquoi avons-nous besoin de comparer membre et non-membre de fonctions? La surcharge d'opérateur, c'est pourquoi. Considérez ceci:

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

foo& operator<<(foo&, char const*); //implementation unimportant

Vous seriez certainement voulez la suite de l'appel de la fonction libre, n'est-ce pas?

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

C'est pourquoi les membres et non-membres les fonctions sont incluses dans le soi-disant surcharge. Pour faire de la résolution de moins en moins compliqué, le gras de la partie de la norme citation existe. En outre, c'est l'important pour nous (même article):

p4 Pour les non-fonctions membres statiques, le type de l'objet implicite paramètre est

• “lvalue référence à cv X” pour les fonctions déclarées sans ref-qualificatif ou avec la & ref-qualificatif

• “référence rvalue à cv X” pour les fonctions déclarées avec le && ref-qualificatif

où X est la classe dont la fonction est membre et cv est le cv-qualification à la fonction de membre de déclaration. [...]

p5 Lors de la résolution de surcharge [...] [l'] objet implicite paramètre [...] conserve son identité depuis des conversions sur l'argument correspondant doit obéir à ces règles supplémentaires:

• pas d'objet temporaire peuvent être introduits pour tenir l'argument de l'objet implicite paramètre; et

• pas de conversions définies par l'utilisateur peuvent être utilisés pour réaliser un type de match avec

[...]

(Le dernier bit signifie simplement que vous ne pouvez pas tricher surcharge de résolution basée sur la conversion implicite de l'objet à une fonction membre (ou l'exploitant) est appelée.)

Prenons le premier exemple en haut de ce post. À compter de la transformation, de la surcharge de jeu ressemble à quelque chose comme ceci:

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

Ensuite la liste des arguments, contenant un implicite de l'objet argumentest en correspondance avec le paramètre-liste de toutes les fonctions contenues dans la surcharge. Dans notre cas, l'argument de la liste ne contiendra que l'argument d'objet. Voyons comment cela ressemble:

//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, après tous les surcharges dans l'ensemble sont testés, un seul reste, la résolution de surcharge réussi et la fonction liée à celle transformé la surcharge est appelé. Il en va de même pour le deuxième appel à '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

Note cependant que, si nous n'avions pas prévu tout ref-qualificatif (et en tant que tel n'est pas surchargé la fonction), qui f1 serait correspondre à une rvalue (encore §13.3.1):

p5 [...] Pour les fonctions membres statiques déclarée sans ref-qualificatifune autre règle s'applique:

• même si l'objet implicite paramètre n'est pas const-qualifiés, une rvalue peut être lié au paramètre aussi longtemps que dans tous les autres égards, l'argument peut être converties dans le type de l'objet implicite paramètre.

struct test{
  void f() { std::cout << "lvalue or rvalue object\n"; }
};

int main(){
  test t;
  t.f(); //OK
  test().f(); //OK too
}

---

Maintenant, sur pourquoi @Nicol réponse est au moins en partie tort. Il dit:

Remarque que cette déclaration change le type de *this.

C'est faux, *this est toujours une lvalue:

§5.3.1 [expr.unary.op] p1

Unaire * opérateur effectue indirection: l'expression à laquelle il est appliqué doit être un pointeur sur un type d'objet, ou un pointeur vers une fonction de type et le résultat est une lvalue se référant à l'objet ou la fonction à laquelle l'expression de points.

§9.3.2 [class.this] p1

Dans le corps d'un non-statique (9.3) de la fonction membre, le mot-clé this est un prvalue expression dont la valeur est l'adresse de l'objet pour lequel la fonction est appelée. Le type de this dans une fonction membre d'une classe X est X*. [...]

Disons que vous avez deux fonctions de classe, avec le même nom et la même signature. Mais l'un d'eux est déclaré const:

void SomeFunc() const;
void SomeFunc();

Si une instance de classe n'est pas constla surcharge de résolution, choisissez de préférence le non-const version. Si l'instance est constl'utilisateur peut seulement appeler les const version. Et le this pointeur est une const pointeur, de sorte que l'instance ne peut pas être changé.

Ce que "r-valeur de référence pour ce` n'est de vous permettre d'ajouter une autre alternative:

void RValueFunc() &&;

Cela vous permet d'avoir une fonction qui peut seulement être appelée si l'utilisateur appelle par le biais d'un bon de r-valeur. Donc, si c'est dans le type Object:

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

De cette façon, vous pouvez vous spécialiser le comportement selon que l'objet est accessible via une r-valeur ou pas.

Notez que vous n'êtes pas autorisé à la surcharge entre la r-valeur de référence et la version non-référence versions. C'est, si vous avez un nom de la fonction membre, toutes ses versions, soit utiliser le l/r-valeur qualificatifs sur thisou aucun d'entre eux n'. Vous ne pouvez pas faire ceci:

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

Vous devez faire ceci:

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

Remarque que cette déclaration change le type de *this. Cela signifie que le && les versions de tous les accès des membres de la r-valeur de référence. Ainsi, il devient possible de déplacer facilement à l'intérieur de l'objet. L'exemple donné dans la première version de la proposition est (remarque: les informations suivantes ne peuvent pas être correct avec la dernière version de C++11; c'est directement à partir de l'initiale "r-valeur de cette" proposition):

class X {
   std::vector<char> data_;
public:
   //...
   std::vector<char> const & data() const & { return data_; }
   std::vector<char> && data() && { return data_; }
};

X f();

//...
X x;
std::vector<char> a = x.data(); //copy
std::vector<char> b = f().data(); //move