In che modo std :: move () trasferisce i valori in RValues?

Mi sono appena ritrovato a non comprendere appieno la logica di std::move().

All'inizio l'ho cercato su Google ma sembra che ci siano solo documenti su come usarlo std::move(), non su come funziona la sua struttura.

Voglio dire, so qual è la funzione del membro del modello, ma quando std::move()esamino la definizione in VS2010, è ancora fonte di confusione.

la definizione di std :: move () va di seguito.

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);
    }

La prima cosa strana per me è il parametro, (_Ty && _Arg), perché quando chiamo la funzione come vedi sotto,

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

fondamentalmente è uguale a

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

Ma come già sai, non puoi collegare direttamente un LValue a un riferimento RValue, il che mi fa pensare che dovrebbe essere così.

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

Tuttavia, questo è assurdo perché std :: move () deve funzionare per tutti i valori.

Quindi immagino che per capire appieno come funziona, dovrei dare un'occhiata anche a queste strutture.

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;
};

Purtroppo è ancora così confuso e non lo capisco.

So che è tutto a causa della mia mancanza di competenze sintattiche di base su C ++. Mi piacerebbe sapere come funzionano a fondo e qualsiasi documento che posso ottenere su Internet sarà più che benvenuto. (Se puoi spiegarlo, anche quello sarà fantastico).

Iniziamo con la funzione di spostamento (che ho ripulito un po '):

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

Cominciamo con la parte più semplice, ovvero quando la funzione viene chiamata con rvalue:

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

e il nostro movemodello viene istanziato come segue:

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

Poiché si remove_referenceconverte T&in To T&&in Te Objectnon è un riferimento, la nostra funzione finale è:

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

Ora, potresti chiederti: abbiamo anche bisogno del cast? La risposta è: sì, lo facciamo. Il motivo è semplice; il riferimento denominato rvalue viene trattato come lvalue (e la conversione implicita da lvalue a rvalue è vietata dallo standard).

Ecco cosa succede quando chiamiamo movecon lvalue:

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

e moveistanziazione corrispondente :

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

Di nuovo, remove_referenceconverte Object&in Objecte otteniamo:

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

Ora arriviamo alla parte difficile: cosa significa Object& &&anche e come può legarsi a lvalue?

Per consentire un inoltro perfetto, lo standard C ++ 11 fornisce regole speciali per la compressione dei riferimenti, che sono le seguenti:

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

Come puoi vedere, in queste regole in Object& &&realtà significa Object&, che è un semplice riferimento a lvalue che consente l'associazione di lvalues.

La funzione finale è quindi:

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

che non è diverso dall'istanza precedente con rvalue: entrambi lanciano il suo argomento su riferimento rvalue e quindi lo restituiscono. La differenza è che la prima istanza può essere utilizzata solo con rvalues, mentre la seconda funziona con lvalues.

Per spiegare perché abbiamo bisogno di remove_referenceun po 'di più, proviamo questa funzione

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

e istanziarlo con lvalue.

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

Applicando le regole di compressione di riferimento sopra menzionate, puoi vedere che otteniamo una funzione che è inutilizzabile come move(per dirla semplicemente, la chiami con lvalue, ottieni indietro lvalue). Se non altro, questa funzione è la funzione di identità.

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

_Ty è un parametro del modello e in questa situazione

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

_Ty è di tipo "Object &"

ecco perché il riferimento _Remove_ è necessario.

Sarebbe più simile

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

Se non rimuovessimo il riferimento, sarebbe come stavamo facendo

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

Ma ObjectRef && si riduce a Object &, che non è stato possibile associare a obj2.

Il motivo per cui si riduce in questo modo è supportare l'inoltro perfetto. Vedi questo documento .