113

我只是发现自己没有完全理解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++ 的基本语法技能。我想知道这些是如何彻底工作的，并且我可以在互联网上获得的任何文件都将受到欢迎。（如果你能解释这一点，那也太棒了）。

4

2 回答 2

184

我们从 move 函数开始（我稍微清理了一下）：

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

让我们从更简单的部分开始 - 即使用右值调用函数时：

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&为Tor T&&，T并且Object不是引用，我们的最终函数是：

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

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

当我们move使用左值调用时会发生以下情况：

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 的实例化没有什么不同——它们都将其参数转换为 rvalue 引用，然后返回它。不同之处在于第一个实例化只能与右值一起使用，而第二个实例化与左值一起使用。

为了解释为什么我们需要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);
}
于 2011-09-22T16:39:37.183 回答
4

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

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

_Ty 是类型“对象 &”

这就是为什么需要 _Remove_reference 的原因。

它会更像

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

如果我们不删除引用，就像我们正在做的那样

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

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

它减少这种方式的原因是支持完美转发。见这篇论文。

于 2011-09-22T06:12:56.697 回答