Les variables déclarées par &&

Question

Réflexion sur les valeurs (x | r | l | | pr gl), la question suivante est venu à mon esprit:

Considérons les deux déclarations de variables suivantes:

X x = ...; 

et

X&& x = ...; 

et supposons que le ... faire pas livrer un xvalue.

Quelqu'un peut-il penser au code pas en utilisant decltype dans lequel cela fait une différence? Dans les deux cas, (x) sera par une valeur de type X, n'est-ce pas?

Answer 1

Modèle arguments non de type cannot refer to a temporary. Ainsi, étant donné

struct X {}; 
X purr() { return {}; } 

X x1 = purr(); 
X&& x2 = purr(); 

template<X&> class woof {}; 

nous avons

woof<x1> w1; // OK 
woof<x2> w2; // Error 

---

Si ... ne se limite pas à un prvalue de type X, puis trancher est une manière moins obscure pour que les deux non équivalentes. Étant donné:

struct X { virtual ~X() = default; }; 
struct Y : X {}; 

Y meow() { return {}; } 

Puis:

X x1 = meow();  // slices 
X&& x2 = meow();  // doesn't slice 

Ainsi:

dynamic_cast<Y&>(x1); // throws std::bad_cast 
dynamic_cast<Y&>(x2); // OK 

Answer 2

Peut-être par exemple artificiel, mais avec

struct X 
{ 
    X() = default; 
    X(const X&) = delete; 
    X operator =(const X&) = delete; 
    X(X&&) = delete; 
    X operator =(X&&) = delete; 
}; 

X makeX() {return {};} 

suivant compile

X&& x = makeX(); 

alors ne explique pas

X x = makeX();