Beim Nachdenken über (x | r | l | pr | gl) -Werte kam mir folgende Frage in den Sinn:

Betrachten Sie die folgenden zwei Variablendeklarationen:

X x = ...;

Und

X&& x = ...;

Und nehmen Sie an, dass ... nicht einen x-Wert liefert.

Kann sich jemand vorstellen, dass Code nicht decltype verwendet, bei dem dies einen Unterschied macht? In beiden Fällen wird (x) einen Wert vom Typ X haben, nicht wahr?

11
JohnB 27 Dez. 2015 im 13:24

2 Antworten

Beste Antwort

Nicht typisierte Argumente für Vorlagen können nicht auf temporäre Argumente verweisen. Also gegeben

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

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

template<X&> class woof {};

Wir haben

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

Wenn ... nicht auf einen Wert vom Typ X beschränkt ist, ist das Schneiden eine weniger dunkle Methode, um die beiden nicht gleichwertig zu machen. Gegeben:

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

Y meow() { return {}; }

Dann:

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

Somit:

dynamic_cast<Y&>(x1); // throws std::bad_cast
dynamic_cast<Y&>(x2); // OK
4
T.C. 27 Dez. 2015 im 15:06

Vielleicht künstliches Beispiel, aber mit

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

X makeX() {return {};}

Folgende Kompilierungen

X&& x = makeX();

Während das Folgen nicht tut

X x = makeX();
6
Jarod42 27 Dez. 2015 im 10:35