Wie überträgt std :: move () Werte in RValues?

Ich habe gerade festgestellt, dass ich die Logik von nicht vollständig verstanden habe std::move().

Zuerst habe ich es gegoogelt, aber es scheint nur Dokumente zu geben, wie man es benutzt std::move(), nicht wie seine Struktur funktioniert.

Ich meine, ich weiß, was die Vorlagenelementfunktion ist, aber wenn ich mir die std::move()Definition in VS2010 anschaue, ist sie immer noch verwirrend.

Die Definition von std :: move () ist unten aufgeführt.

template<class _Ty> inline
typename tr1::_Remove_reference<_Ty>::_Type&&
    move(_Ty&& _Arg)
    {   // forward _Arg as movable
        return ((typename tr1::_Remove_reference<_Ty>::_Type&&)_Arg);
    }

Was mir zuerst komisch ist, ist der Parameter (_Ty && _Arg), denn wenn ich die Funktion aufrufe, wie Sie unten sehen,

// main()
Object obj1;
Object obj2 = std::move(obj1);

es ist im Grunde gleich

// std::move()
_Ty&& _Arg = Obj1;

Aber wie Sie bereits wissen, können Sie einen LValue nicht direkt mit einer RValue-Referenz verknüpfen, weshalb ich denke, dass dies so sein sollte.

_Ty&& _Arg = (Object&&)obj1;

Dies ist jedoch absurd, da std :: move () für alle Werte funktionieren muss.

Um zu verstehen, wie das funktioniert, sollte ich mir auch diese Strukturen ansehen.

template<class _Ty>
struct _Remove_reference
{   // remove reference
    typedef _Ty _Type;
};

template<class _Ty>
struct _Remove_reference<_Ty&>
{   // remove reference
    typedef _Ty _Type;
};

template<class _Ty>
struct _Remove_reference<_Ty&&>
{   // remove rvalue reference
    typedef _Ty _Type;
};

Leider ist es immer noch so verwirrend und ich verstehe es nicht.

Ich weiß, dass dies alles auf meinen Mangel an grundlegenden Syntaxkenntnissen in C ++ zurückzuführen ist. Ich würde gerne wissen, wie diese gründlich funktionieren, und alle Dokumente, die ich im Internet erhalten kann, werden mehr als begrüßt. (Wenn Sie dies nur erklären können, wird das auch fantastisch sein).

Wir beginnen mit der Verschiebungsfunktion (die ich ein wenig aufgeräumt habe):

template <typename T>
typename remove_reference<T>::type&& move(T&& arg)
{
  return static_cast<typename remove_reference<T>::type&&>(arg);
}

Beginnen wir mit dem einfacheren Teil - das heißt, wenn die Funktion mit rvalue aufgerufen wird:

Object a = std::move(Object());
// Object() is temporary, which is prvalue

und unsere moveVorlage wird wie folgt instanziiert:

// move with [T = Object]:
remove_reference<Object>::type&& move(Object&& arg)
{
  return static_cast<remove_reference<Object>::type&&>(arg);
}

Da remove_referencekonvertiert T&zu Toder T&&zu Tund Objectkeine Referenz ist, lautet unsere letzte Funktion:

Object&& move(Object&& arg)
{
  return static_cast<Object&&>(arg);
}

Nun fragen Sie sich vielleicht: Brauchen wir überhaupt die Besetzung? Die Antwort lautet: Ja, das tun wir. Der Grund ist einfach; Die benannte rWertreferenz wird als lWert behandelt (und die implizite Konvertierung von lWert in rWertreferenz ist standardmäßig verboten).

moveFolgendes passiert, wenn wir mit lvalue aufrufen:

Object a; // a is lvalue
Object b = std::move(a);

und entsprechende moveInstanziierung:

// move with [T = Object&]
remove_reference<Object&>::type&& move(Object& && arg)
{
  return static_cast<remove_reference<Object&>::type&&>(arg);
}

Wieder remove_referencekonvertiert Object&zu Objectund wir bekommen:

Object&& move(Object& && arg)
{
  return static_cast<Object&&>(arg);
}

Jetzt kommen wir zum kniffligen Teil: Was bedeutet das Object& &&überhaupt und wie kann es an den Wert binden?

Um eine perfekte Weiterleitung zu ermöglichen, bietet der C ++ 11-Standard spezielle Regeln für das Reduzieren von Referenzen:

Object &  &  = Object &
Object &  && = Object &
Object && &  = Object &
Object && && = Object &&

Wie Sie sehen können, bedeutet unter diesen Regeln Object& &&tatsächlich Object&, dass es sich um eine einfache L-Wert-Referenz handelt, die das Binden von L-Werten ermöglicht.

Die letzte Funktion ist also:

Object&& move(Object& arg)
{
  return static_cast<Object&&>(arg);
}

Das ist nicht anders als bei der vorherigen Instanziierung mit rvalue - beide werfen ihr Argument auf die rvalue-Referenz und geben es dann zurück. Der Unterschied besteht darin, dass die erste Instanziierung nur mit r-Werten verwendet werden kann, während die zweite mit l-Werten arbeitet.

Um zu erklären, warum wir remove_referenceetwas mehr brauchen , versuchen wir diese Funktion

template <typename T>
T&& wanna_be_move(T&& arg)
{
  return static_cast<T&&>(arg);
}

und instanziiere es mit lvalue.

// wanna_be_move [with T = Object&]
Object& && wanna_be_move(Object& && arg)
{
  return static_cast<Object& &&>(arg);
}

Wenn Sie die oben erwähnten Regeln zum moveReduzieren von Referenzen anwenden, können Sie sehen, dass wir eine Funktion erhalten, die unbrauchbar ist (um es einfach auszudrücken, Sie rufen sie mit lvalue auf, Sie erhalten lvalue zurück). Wenn überhaupt, ist diese Funktion die Identitätsfunktion.

Object& wanna_be_move(Object& arg)
{
  return static_cast<Object&>(arg);
}

_Ty ist in dieser Situation ein Vorlagenparameter

Object obj1;
Object obj2 = std::move(obj1);

_Ty ist der Typ "Object &"

Aus diesem Grund ist die Referenz "Entfernen" erforderlich.

Es wäre eher so

typedef Object& ObjectRef;
Object obj1;
ObjectRef&& obj1_ref = obj1;
Object&& obj2 = (Object&&)obj1_ref;

Wenn wir die Referenz nicht entfernen würden, wäre es so, wie wir es tun würden

Object&& obj2 = (ObjectRef&&)obj1_ref;

ObjectRef && reduziert sich jedoch auf Object &, das wir nicht an obj2 binden konnten.

Der Grund dafür ist die Unterstützung einer perfekten Weiterleitung. Siehe dieses Papier .