Que signifie l'esperluette simple ici?

Question

De la réponse ici .

 class wrap {
public:
   operator obj() const & { ... }   //Copy from me.
   operator obj() && { ... }  //Move from me.
private:
   obj data_;
};
 

Je sais que && signifie que le membre sera invoqué lorsque l'objet est une référence rvalue. Mais que signifie la seule esperluette? En quoi est-ce différent que sans l'esperluette?

Answer 1

Cela signifie que le membre sera appelée lorsque l'objet est une lvalue de référence.

[C++11: 9.3.1/5]: Non-membre statique de la fonction peut être déclarée avec une ref de qualificateur (8.3.5); voir la section 13.3.1.

[C++11: 13.3.1/4]: Pour les non-fonctions membres statiques, le type de l'objet implicite paramètre est

• "lvalue de référence pour cv X" pour les fonctions déclarées sans ref-qualificatif ou avec l' & ref-qualifier
• "référence rvalue de cv X" pour les fonctions déclarées avec l' && ref-qualifier

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

(et un peu plus de règles que je ne peux pas trouver)

Sans ref-qualificatif, la fonction peut toujours être invoquée, quelle que soit la valeur de la catégorie de l'expression par laquelle vous êtes en invoquant ça:

struct foo
{
    void bar() {}
    void bar1() & {}
    void bar2() && {}
};

int main()
{
    foo().bar();  // (always fine)
    foo().bar1(); // doesn't compile because bar1() requires an lvalue
    foo().bar2();

    foo f;
    f.bar();      // (always fine)
    f.bar1();
    f.bar2();     // doesn't compile because bar2() requires an rvalue
}

Démonstration en direct ^{(grâce Prétorienne)}

Answer 2

Mais que signifie la seule esperluette?

La fonction ne peut être appelée que sur une lvalue, pas sur une rvalue.

En quoi est-ce différent que sans l'esperluette?

Sans qualificatif ref, vous pouvez invoquer la fonction sur une lvalue ou une rvalue.

Avec un qualificatif ref, vous ne pouvez appeler la fonction que sur la catégorie de valeur correspondante.

Answer 3

Une fonction sans ref-qualificatif peut être appelé pour les deux rvalue et lvalues. Une fonction avec un && ref-qualificatif ne peut être appelée que pour les rvalues. Une fonction avec un & ref-qualificatif ne peut être appelée que pour lvalues.

class No { void foo(); };
class L { void foo() &; };
class R { void foo() &&; };

No().foo(); // valid
No no; no.foo(); // valid
L().foo(); // invalid
L l; l.foo(); // valid
R().foo(); // valid
R r; r.foo(); // invalid

Malheureusement, je ne peux que trouver cette règle 5.5/6, qui s'applique uniquement aux pointeur vers membre de déréférencement des expressions. Je sais que cela s'applique, si trop.

En outre, vous ne pouvez pas surcharger sur ref-qualificatif vs pas de ref-qualificatif, voir 13.1/2 point 3. Vous pouvez surcharge sur & vs &&.

(Et en raison de ma recherche infructueuse de la norme, LRiO de répondre a toutes les info en trop.)