Как std :: move () передает значения в RValues?

Я просто обнаружил, что не до конца понимаю логику std::move().

Сначала я погуглил, но похоже, что есть только документы о том, как использовать std::move(), а не о том , как работает его структура.

Я имею в виду, что я знаю, что такое функция-член шаблона, но когда я смотрю на std::move()определение в VS2010, это все еще сбивает с толку.

определение std :: move () приведено ниже.

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

В первую очередь мне кажется странным параметр (_Ty && _Arg), потому что, когда я вызываю функцию, как вы видите ниже,

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

это в основном равно

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

Но, как вы уже знаете, вы не можете напрямую связать LValue со ссылкой на RValue, что заставляет меня думать, что это должно быть так.

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

Однако это абсурд, потому что std :: move () должен работать для всех значений.

Итак, я думаю, чтобы полностью понять, как это работает, я должен также взглянуть на эти структуры.

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

К сожалению, это все еще сбивает с толку, и я этого не понимаю.

Я знаю, что это все из-за отсутствия у меня базовых навыков синтаксиса в C ++. Я хотел бы знать, как они работают, и любые документы, которые я могу найти в Интернете, будут более чем приветствоваться. (Если вы можете просто объяснить это, это тоже будет круто).

Начнем с функции перемещения (которую я немного очистил):

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

Начнем с более простой части - то есть, когда функция вызывается с rvalue:

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

и наш moveшаблон создается следующим образом:

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

Поскольку remove_referenceконвертирует T&в Tили T&&в Tи Objectне является ссылкой, наша последняя функция:

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

Теперь вы можете спросить: а нужен ли нам гипс? Ответ: да, есть. Причина проста; названный справочник Rvalue будет рассматриваться как именующие (и неявное преобразование из именующих в RValue ссылки запрещено стандарт).

Вот что происходит, когда мы вызываем moveс lvalue:

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

и соответствующий moveэкземпляр:

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

Опять remove_referenceконвертируем Object&в Objectи получаем:

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

Теперь мы переходим к сложной части: что вообще Object& &&означает и как оно может быть привязано к lvalue?

Чтобы обеспечить идеальную пересылку, стандарт C ++ 11 предоставляет специальные правила для сворачивания ссылок, а именно:

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

Как видите, под этими правилами на Object& &&самом деле подразумевается Object&простая ссылка lvalue, которая позволяет связывать lvalue.

Таким образом, конечная функция:

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

что мало чем отличается от предыдущего экземпляра с rvalue - они оба приводят свой аргумент к ссылке rvalue, а затем возвращают ее. Разница в том, что первый экземпляр можно использовать только с rvalues, а второй работает с lvalues.

Чтобы объяснить, почему нам нужно remove_referenceнемного больше, давайте попробуем эту функцию

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

и создайте его с помощью lvalue.

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

Применяя упомянутые выше правила сворачивания ссылок, вы можете увидеть, что мы получаем функцию, которую нельзя использовать как move(проще говоря, вы вызываете ее с lvalue, вы получаете lvalue обратно). Во всяком случае, эта функция является функцией идентичности.

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

_Ty - это параметр шаблона, и в этой ситуации

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

_Ty - это тип "Object &"

поэтому необходима ссылка _Remove_reference.

Было бы больше похоже

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

Если бы мы не удалили ссылку, это было бы так, как если бы мы делали

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

Но ObjectRef && сводится к Object &, который мы не могли привязать к obj2.

Причина, по которой он сокращается таким образом, заключается в поддержке идеальной пересылки. См. Эту статью .