Як 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& &&переходимо до хитромудрої частини: що це означає і як це може бути пов'язане з значенням?

Щоб домогтися ідеального переадресації, стандарт C ++ 11 забезпечує спеціальні правила згортання посилань, які є наступними:

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

Як бачите, під цими правилами Object& &&насправді мається на увазі Object&, що є простим посиланням на значення, яке дозволяє прив'язувати значення.

Кінцева функція, таким чином:

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

що не відрізняється від попередньої інстанції з 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);

_Ти є тип "Об'єкт &"

саме тому _Remove_reference необхідний.

Це було б більше схоже

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

Якби ми не видалили посилання, це було б так, як ми це робили

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

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

Причина, якою він зменшує цей спосіб, - підтримка ідеального переадресації. Дивіться цей документ .