我在这里使用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)

适合。

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

在使用std::forward或在不同时间确定的函数调用中是否推导出T并不重要（例如在您的示例中，其中T是在实例化Node模板时确定的）。

std::forward<T>(value)将以与调用者直接调用基类构造函数相同的方式调用继承的构造函数。 也就是说，当value是左值时，它将在左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& ，你只接受非const lvalue int ，如果T是一个int const& ，您接受任何可转换为int值。

这将是一组奇怪的要求放在NodeBase的构造函数上。 我可以想到可能出现这种情况的情况，但它们并不常见。

假设你只是想让NodeBase存储那些数据，那么在构造函数中使用T&&是不对的 - 如果你在NodeBase中存储一个int ，你可能愿意复制那个int ，而不是只接受移动 -来自int 。

上面的代码就是这样 - 它允许任何可以存储在NodeBase中的NodeBase传递到所述NodeBase ，并具有完美的转发功能。

另一方面，如果你真的想要一组奇怪的结构限制，那么这对你来说不是正确的答案。 我在构建从通用引用参数构建的template类型时使用了它，并且我确实想要限制传入的类型以完全匹配通用引用参数，并且如果参数是rvalue引用则存储它，并以其他方式保留对它的引用。

Answer 3

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

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