Làm thế nào để std :: move () chuyển các giá trị vào RValues?

Tôi chỉ thấy mình không hiểu đầy đủ logic của std::move().

Lúc đầu, tôi truy cập vào nó nhưng có vẻ như chỉ có tài liệu về cách sử dụng std::move()chứ không phải cách hoạt động của cấu trúc.

Ý tôi là, tôi biết hàm thành viên mẫu là gì nhưng khi tôi nhìn vào std::move()định nghĩa trong VS2010, nó vẫn còn khó hiểu.

định nghĩa của std :: move () ở bên dưới.

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

Điều kỳ lạ đối với tôi đầu tiên là tham số, (_Ty && _Arg), bởi vì khi tôi gọi hàm như bạn thấy bên dưới,

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

về cơ bản nó tương đương với

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

Nhưng như bạn đã biết, bạn không thể liên kết trực tiếp LValue với tham chiếu RValue, điều này khiến tôi nghĩ rằng nó phải như thế này.

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

Tuy nhiên, điều này là vô lý vì std :: move () phải hoạt động với tất cả các giá trị.

Vì vậy, tôi đoán để hiểu đầy đủ cách hoạt động của nó, tôi cũng nên xem các cấu trúc này.

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

Thật không may, nó vẫn khó hiểu và tôi không hiểu.

Tôi biết rằng tất cả là do tôi thiếu kỹ năng cú pháp cơ bản về C ++. Tôi muốn biết cách thức hoạt động của những thứ này và bất kỳ tài liệu nào tôi có thể lấy trên internet sẽ được hoan nghênh hơn cả. (Nếu bạn có thể giải thích điều này, điều đó cũng sẽ tuyệt vời).

Chúng tôi bắt đầu với chức năng di chuyển (mà tôi đã làm sạch một chút):

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

Hãy bắt đầu với phần dễ dàng hơn - đó là khi hàm được gọi với rvalue:

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

và movemẫu của chúng tôi được khởi tạo như sau:

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

Vì remove_referencechuyển đổi T&thành Thoặc T&&thành T, và Objectkhông phải là tham chiếu, chức năng cuối cùng của chúng ta là:

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

Bây giờ, bạn có thể tự hỏi: chúng ta có cần dàn diễn viên không? Câu trả lời là: có, chúng tôi làm. Lý do rất đơn giản; tham chiếu rvalue có tên được coi là lvalue (và việc chuyển đổi ngầm định từ tham chiếu lvalue sang rvalue bị cấm theo tiêu chuẩn).

Đây là những gì sẽ xảy ra khi chúng ta gọi movevới lvalue:

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

và movekhởi tạo tương ứng :

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

Một lần nữa, remove_referencechuyển đổi Object&thành Objectvà chúng tôi nhận được:

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

Bây giờ chúng ta đến phần khó: Object& &&thậm chí có nghĩa là gì và làm thế nào nó có thể liên kết với lvalue?

Để cho phép chuyển tiếp hoàn hảo, tiêu chuẩn C ++ 11 cung cấp các quy tắc đặc biệt để thu gọn tham chiếu, như sau:

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

Như bạn có thể thấy, theo các quy tắc này Object& &&thực sự có nghĩa là Object&, đó là tham chiếu giá trị đơn giản cho phép các giá trị liên kết.

Chức năng cuối cùng là:

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

điều này không giống như khởi tạo trước đó với rvalue - cả hai đều chuyển đối số của nó thành tham chiếu rvalue và sau đó trả về nó. Sự khác biệt là bản tạo đầu tiên chỉ có thể được sử dụng với các giá trị, trong khi phần thứ hai hoạt động với các giá trị.

Để giải thích tại sao chúng ta cần remove_referencethêm một chút nữa, hãy thử hàm này

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

và khởi tạo nó bằng lvalue.

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

Áp dụng các quy tắc thu gọn tham chiếu được đề cập ở trên, bạn có thể thấy chúng ta nhận được hàm không sử dụng được move(nói một cách đơn giản, bạn gọi nó bằng lvalue, bạn nhận lại lvalue). Nếu bất cứ điều gì, chức năng này là chức năng nhận dạng.

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

_Ty là một tham số mẫu và trong tình huống này

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

_Ty là loại "Đối tượng &"

đó là lý do tại sao _Remove_reference là cần thiết.

Nó sẽ giống hơn

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

Nếu chúng tôi không xóa tham chiếu, nó sẽ giống như chúng tôi đang làm

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

Nhưng ObjectRef && giảm thành Object &, mà chúng tôi không thể liên kết với obj2.

Lý do nó giảm theo cách này là để hỗ trợ chuyển tiếp hoàn hảo. Xem bài báo này .