我在这里使用 std::forward 还是 std::move ？

Question

假设我有：

template<class T>
struct NodeBase
{
    T value;
    NodeBase(T &&value)
        : value(value) { }
};

我继承了它：

template<class T>
struct Node : public NodeBase<T>
{
    Node(T &&value)
        : NodeBase( WHAT_GOES_HERE (value)) { }
};

WHAT_GOES_HERE 应该是 std::move 还是 std::forward<T>？为什么？

Answer 1

由于在 Node<T> 的构造函数的实现中，不知道 T 是普通类型（即不是引用）还是引用，

std::forward<T>(value)

适合。

std::forward<T>(value) 在不知道T && 是绑定到右值还是左值时是正确的选择。这里是这种情况，因为在构造函数中，我们不知道对于某些普通类型U，T && 是否等同于U &&，或者等同于U & &&。

T 是在使用 std::forward 的函数调用中推导出来还是在不同时间确定（例如在您的示例中，T 是在 Node模板已实例化）。

std::forward<T>(value) 将调用继承的构造函数，就像调用者直接调用基类构造函数一样。即，当value 是左值时，它将在左值上调用它，当value 是右值时，它将在右值上调用它。

Answer 2

可能两者都没有。

我怀疑你应该拥有的是：

template<class T>
struct NodeBase
{
  T value;
  NodeBase(NodeBase &&) = default;
  NodeBase(NodeBase const&) = default; // issue: this might not work with a `T&`, but we can conditionally exclude it through some more fancy footwork
  NodeBase(NodeBase &) = default;
  template<typename U, typename=typename std:enable_if< std::is_convertible<U&&, T>::value >::type >
  NodeBase(U &&u)
    : value(std::forward<U>(u)) { }
};

template<class T>
struct Node : public NodeBase<T>
{
  Node( Node & ) = default;
  Node( Node const& ) = default; // issue: this might not work with a `T&`, but we can conditionally exclude it through some more fancy footwork
  Node( Node && ) = default;
  template<typename U, typename=typename std:enable_if< std::is_convertible<U&&, NodeBase<T>>::value >::type>
  Node(U && u)
    : NodeBase( std::forward<U>(u) ) { }
};

除非你正在做一些非常奇怪的事情。

非常奇怪，这意味着如果您的T 是int，您只想接受移动值到您的Node，但如果您的T 是int&，您接受只有非常量左值ints，如果T 是int const&，则接受任何可转换为int 的值。

这对NodeBase 的构造函数提出了一组奇怪的要求。我能想到可能会出现这种情况的情况，但并不常见。

假设您只是希望NodeBase 存储该数据，在构造函数中使用T&& 是不正确的做法——如果您在NodeBase 中存储int，您可能愿意int 的副本，而不是只接受从 ints 移出的。

上面的代码正是这样做的——它允许任何可以存储在NodeBase中的东西都可以通过完美的转发传递到NodeBase。

另一方面，如果您真的想要一组奇怪的构造限制，那么这不是您的正确答案。我在构建从通用引用参数构建的template 类型时使用过它，并且我确实想限制传入的类型以完全匹配通用引用参数，并在参数是右值引用，否则保留对它的引用。

Answer 3

T 在您的示例中没有推断出来。 T 是类模板参数，而不是函数模板参数。因此，假设您不会将引用类型用作 T，T&& 将是对 T 的右值引用，因此它只会绑定到 T 类型的右值。这些将是安全的，因此您可以在此处使用std::move。

template<class T>
struct Node : public NodeBase<T>
{
    Node(T &&value)
        : NodeBase( std::move (value)) { }
};

int main()
{
    int i = 3;

    Node<int> x(42); // ok
    Node<int> y(std::move(i)); // ok
    Node<int> z(i); // error
}

std::forward 通常仅适用于推导类型可能是左值引用或右值引用的地方。

template<class T>
void f(T&& x)
{
    ... std::forward<T>(x) ...
}

因为T&& 实际上可能是左值引用或右值引用。这只是因为T是在这个上下文中推导出来的。