Como std :: move () transfere valores para RValues?

Eu simplesmente não entendi totalmente a lógica de std::move().

A princípio, pesquisei no Google, mas parece que só existem documentos sobre como usar std::move(), não como funciona sua estrutura.

Quer dizer, eu sei o que a função de membro do modelo é, mas quando eu olho para a std::move()definição no VS2010, ainda é confuso.

a definição de std :: move () segue abaixo.

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

O que é estranho primeiro para mim é o parâmetro, (_Ty && _Arg), porque quando eu chamo a função como você vê abaixo,

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

basicamente é igual a

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

Mas como você já sabe, não é possível vincular diretamente um LValue a uma referência RValue, o que me faz pensar que deveria ser assim.

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

No entanto, isso é absurdo porque std :: move () deve funcionar para todos os valores.

Acho que, para entender totalmente como isso funciona, devo dar uma olhada nessas estruturas também.

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

Infelizmente, ainda é tão confuso e eu não entendo.

Eu sei que tudo isso é devido à minha falta de habilidades básicas de sintaxe sobre C ++. Gostaria de saber como funcionam bem e quaisquer documentos que eu conseguir na internet serão mais do que bem-vindos. (Se você puder explicar isso, também será incrível).

Começamos com a função mover (que eu limpei um pouco):

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

Vamos começar com a parte mais fácil - isto é, quando a função é chamada com rvalue:

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

e nosso movemodelo é instanciado da seguinte maneira:

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

Uma vez que remove_referenceconverte T&para Tou T&&para T, e Objectnão é referência, nossa função final é:

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

Agora, você pode se perguntar: nós ainda precisamos do elenco? A resposta é: sim, temos. A razão é simples; a referência de rvalue nomeada é tratada como lvalue (e a conversão implícita de lvalue para a referência de rvalue é proibida por padrão).

Aqui está o que acontece quando chamamos movecom lvalue:

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

e a moveinstanciação correspondente :

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

Novamente, remove_referenceconverte Object&para Objecte nós obtemos:

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

Agora chegamos à parte complicada: o que Object& &&significa e como pode ser vinculado a lvalue?

Para permitir o encaminhamento perfeito, o padrão C ++ 11 fornece regras especiais para recolhimento de referência, que são as seguintes:

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

Como você pode ver, sob essas regras, Object& &&na verdade Object&, significa que é uma referência lvalue simples que permite vincular lvalues.

A função final é assim:

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

que não é diferente da instanciação anterior com rvalue - ambos lançam seu argumento para a referência rvalue e, em seguida, o retornam. A diferença é que a primeira instanciação pode ser usada apenas com rvalues, enquanto a segunda funciona com lvalues.

Para explicar por que precisamos de remove_referenceum pouco mais, vamos tentar esta função

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

e instancie-o com lvalue.

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

Aplicando as regras de recolhimento de referência mencionadas acima, você pode ver que obtemos uma função que é inutilizável como move(para simplificar, você a chama com lvalue e obtém lvalue de volta). No mínimo, essa função é a função de identidade.

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

_Ty é um parâmetro de modelo e, nesta situação

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

_Ty é o tipo "Objeto &"

é por isso que _Remove_reference é necessário.

Seria mais como

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

Se não removêssemos a referência, seria como se estivéssemos fazendo

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

Mas ObjectRef && se reduz a Object &, que não poderíamos vincular a obj2.

A razão pela qual ele reduz dessa forma é para suportar o encaminhamento perfeito. Veja este artigo .