std::move 如何将表达式转换为右值？

Question

我不完全理解 std::move() 的实现。 也就是说，我对 MSVC 标准库中的这种实现感到困惑：

模板排队
类型名 tr1::_Remove_reference<_Ty>::_Type&&
移动（_Ty&&_Arg）
{ // 将 _Arg 转发为可移动
    return ((typename tr1::_Remove_reference<_Ty>::_Type&&)_Arg);
}

当我像这样调用 std::move 时：

Object obj1;
Object obj2 = std::move(obj1); // _Ty&& _Arg binds to obj1

... _Arg 引用参数绑定到左值 obj1。 您不能直接将右值引用绑定到左值，这让我认为需要强制转换为像 (Object&&) 这样的右值引用。 然而，这是荒谬的，因为 std::move() 必须适用于所有值。

为了完全理解它是如何工作的，我也研究了 std::remove_reference 的实现：

模板
结构体_Remove_reference
{ // 删除引用
    typedef _Ty _Type；
};

模板<类_Ty>
结构_Remove_reference<_Ty>
{ // 删除引用
    typedef _Ty _Type；
};

模板<类_Ty>
结构体_Remove_reference<_Ty&>
{ // 删除右值引用
    typedef _Ty _Type；
};

不幸的是，它仍然令人困惑，我不明白。 请帮助我理解 std::move 的实现。

Answer 1

我们从 move 函数开始（我对其进行了一些清理）：

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

现在，您可能想知道：我们还需要演员阵容吗？答案是：是的，我们愿意。原因很简单；命名右值引用被视为左值（标准禁止从左值到右值引用的隐式转换）。

---

时发生的情况

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

以下是当我们使用左值调用 move和相应的 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);
}

这与之前使用右值的实例化没有什么不同 - 它们都将其参数转换为右值引用，然后返回它。不同之处在于，第一个实例化只能与右值一起使用，而第二个实例化则与左值一起使用。

---

为了解释为什么我们还需要 remove_reference ，让我们尝试一下这个函数

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

并用左值实例化它。

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

应用上面提到的引用折叠规则，你可以看到我们得到了无法使用 move 的函数（简单来说，你用左值调用它，你会得到左值）。如果有的话，这个函数就是恒等函数。

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

Answer 2

_Ty 是模板参数，在这种情况下

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

_Ty 是类型“Object &”

这就是为什么 _Remove_reference 是必要的。

But

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

如果我们没有删除引用，它会更像我们正在做的那样

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

ObjectRef&&简化为 Object &，我们无法将其绑定到 obj2。

之所以减少这种方式，是为了支持完美转发。请参阅本文。