将通用构造函数分配给 C++ 中的成员变量时的 std::move 或 std::forward

Question

考虑以下类 foo1 和 foo2

template <typename T>
struct foo1
{
    T t_;

    foo1(T&& t) :
        t_{ std::move(t) }
    {
    }
};

template <typename T>
struct foo2
{
    foo1<T> t_;

    foo2(T&& t) :
        t_{ std::forward<T>(t) }
    {
    }
};

是否总是foo1的构造函数代表了初始化成员变量T的正确方式？即使用std::move。

foo2的构造函数是否总是因为需要转发给foo1的构造函数而代表初始化成员变量foo1<T>的正确方法？即使用std::forward。

更新

对于使用std::move 的foo1，以下示例失败：

template <typename T>
foo1<T> make_foo1(T&& t)
{
    return{ std::forward<T>(t) };
}

struct bah {};

int main()
{
    bah b;

    make_foo1(b); // compiler error as std::move cannot be used on reference

    return EXIT_SUCCESS;
}

这是一个问题，因为我希望 T 既是引用类型又是值类型。

Answer 1

这些示例都没有使用通用引用（转发引用，因为它们现在被称为）。

转发引用只在存在类型推导的情况下形成，但foo1和foo2的构造函数中的T&&没有推导，所以它只是一个右值引用。

由于两者都是右值引用，您应该在两者上都使用std::move。

如果你想使用转发引用，你应该让构造函数有一个推导的模板参数：

template <typename T>
struct foo1
{
    T t_;

    template <typename U>
    foo1(U&& u) :
        t_{ std::forward<U>(u) }
    {
    }
};

template <typename T>
struct foo2
{
    foo1<T> t_;

    template <typename U>
    foo2(U&& u) :
        t_{ std::forward<U>(u) }
    {
    }
};

在这种情况下，您不应在 foo1 中使用 std::move，因为客户端代码可能会传递左值并让对象静默失效：

std::vector<int> v {0,1,2};
foo1<std::vector<int>> foo = v;
std::cout << v[2]; //yay, undefined behaviour

更简单的方法是按值无条件地将std::move 带入存储：

template <typename T>
struct foo1
{
    T t_;

    foo1(T t) :
        t_{ std::move(t) }
    {
    }
};

template <typename T>
struct foo2
{
    foo1<T> t_;

    foo2(T t) :
        t_{ std::move(t) }
    {
    }
};

对于完美的转发版本：

• 传递左值 -> 一份
• 通过右值 -> 一招

对于传值和移动版本：

• 传左值 -> 一份，一招
• 通过右值 -> 两步

考虑此代码需要的性能以及需要对其进行多少更改和维护，并据此选择一个选项。

Answer 2

这取决于你如何推断​​T。例如：

template<class T>
foo1<T> make_foo1( T&& t ) {
  return std::forward<T>(t);
}

在这种情况下，foo1<T> 中的 T 是转发引用，您的代码将无法编译。

std::vector<int> bob{1,2,3};
auto foo = make_foo1(bob);

上述代码在构造函数中从bob 静默移动到std::vector<int>& 到foo1<std::vector<int>&>。

对foo2 做同样的事情会奏效。你会得到一个foo2<std::vector<int>&>，它会引用bob。

在编写模板时，必须考虑要引用的类型 T 意味着什么。如果您的代码不支持将其作为参考，请考虑使用static_assert 或 SFINAE 来阻止这种情况。

template <typename T>
struct foo1 {
  static_assert(!std::is_reference<T>{});
  T t_;

  foo1(T&& t) :
    t_{ std::move(t) }
  {
  }
};

现在这段代码会生成一个合理的错误信息。

您可能认为现有的错误消息没问题，但它只是因为我们移到了T。

template <typename T>
struct foo1 {
  static_assert(!std::is_reference<T>{});

  foo1(T&& t)
  {
    auto internal_t = std::move(t);
  }
};

这里只有static_assert 确保我们的T&& 是实际的右值。

---

但是对于这个理论上的问题列表已经足够了。你有一个具体的。

最后这可能是你想要的：

template <class T> // typename is too many letters
struct foo1 {
  static_assert(!std::is_reference<T>{});
  T t_;

  template<class U,
    class dU=std::decay_t<U>, // or remove ref and cv
    // SFINAE guard required for all reasonable 1-argument forwarding
    // reference constructors:
    std::enable_if_t<
      !std::is_same<dU, foo1>{} && // does not apply to `foo1` itself
      std::is_convertible<U, T> // fail early, instead of in body
    ,int> = 0
  >
  foo1(U&& u):
    t_(std::forward<U>(u))
  {}
  // explicitly default special member functions:
  foo1()=default;
  foo1(foo1 const&)=default;
  foo1(foo1 &&)=default;
  foo1& operator=(foo1 const&)=default;
  foo1& operator=(foo1 &&)=default;
};

或者，在 99/100 情况下也一样好的更简单的情况：

template <class T>
struct foo1 {
  static_assert(!std::is_reference<T>{});
  T t_;

  foo1(T t) :
    t_{ std::move(t) }
  {}
  // default special member functions, just because I never ever
  // want to have to memorize the rules that makes them not exist
  // or exist based on what other code I have written:
  foo1()=default;
  foo1(foo1 const&)=default;
  foo1(foo1 &&)=default;
  foo1& operator=(foo1 const&)=default;
  foo1& operator=(foo1 &&)=default;
};

作为一般规则，这种更简单的技术比完美的转发技术多移动 1 步，以换取大量更少的代码和复杂性。它允许 {} 初始化构造函数的 T t 参数，这很好。