std :: move () โอนค่าไปยัง RValues ​​ได้อย่างไร

ฉันเพิ่งพบว่าตัวเองไม่เข้าใจตรรกะของstd::move().

ตอนแรกฉันใช้ googled แต่ดูเหมือนว่าจะมีเพียงเอกสารเกี่ยวกับวิธีใช้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 ถือว่าเป็น lvalue (และการแปลงโดยนัยจาก lvalue เป็น rvalue เป็นสิ่งต้องห้ามตามมาตรฐาน)

นี่คือสิ่งที่เกิดขึ้นเมื่อเราโทรหาmovelvalue:

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 ธรรมดาที่อนุญาตให้มีค่าผูกมัด

ฟังก์ชันสุดท้ายคือ:

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 ได้

เหตุผลที่ลดวิธีนี้คือการสนับสนุนการส่งต่อที่สมบูรณ์แบบ ดูกระดาษนี้