如何在不使用 std::forward 的情况下调用成员变量的移动构造函数？

Question

here 的示例 std::forward，

// forward example
#include <utility>      // std::forward
#include <iostream>     // std::cout

// function with lvalue and rvalue reference overloads:
void overloaded (const int& x) {std::cout << "[lvalue]";}
void overloaded (int&& x) {std::cout << "[rvalue]";}

// function template taking rvalue reference to deduced type:
template <class T> void fn (T&& x) {
  overloaded (x);                   // always an lvalue
  overloaded (std::forward<T>(x));  // rvalue if argument is rvalue
}

int main () {
  int a;

  std::cout << "calling fn with lvalue: ";
  fn (a);
  std::cout << '\n';

  std::cout << "calling fn with rvalue: ";
  fn (0);
  std::cout << '\n';

  return 0;
}

Output:
calling fn with lvalue: [lvalue][lvalue]
calling fn with rvalue: [lvalue][rvalue]

提到

所有命名值（例如函数参数）总是 评估为左值（即使是那些声明为右值引用的）

然而，典型的移动构造函数看起来像

ClassName(ClassName&& other)
   : _data(other._data)
{
}

看起来像_data(other._data) 应该调用_data 类的移动构造函数。但是，不使用std::forward 怎么可能呢？换句话说，不应该吗

ClassName(ClassName&& other)
   : _data(std::forward(other._data))
{
}

?

因为正如在 std:forward 案例中指出的那样，

所有命名的值都应该评估为左值

我越来越喜欢 C++，因为这样的问题有深度，而且语言足够大胆，可以提供这样的功能：) 谢谢！

Answer 1

典型的移动构造函数如下所示（假设它已显式实现：您可能更喜欢= default）：

ClassName::ClassName(ClassName&& other)
    : _data(std::move(other._data)) {
}

没有std::move()，成员被复制：因为它有一个名字other是一个左值。但是，引用绑定到的对象是右值或被视为右值的对象。

std::forward<T>(obj)总是与显式模板参数一起使用。在实践中，类型是为转发参考推导出的。这些看起来非常像右值引用，但它们完全不同！特别是，转发引用可以引用左值。

您可能对我的Two Daemons 文章感兴趣，该文章详细描述了差异。

Answer 2

std::forward 应与forwarding reference 一起使用。
std::move 应与rvalue reference 一起使用。

构造函数没有什么特别之处。这些规则同样适用于任何函数、成员函数或构造函数。

最重要的是要意识到何时拥有forwarding reference 和何时拥有rvalue reference。它们看起来相似但实际上并不相似。

转发引用始终采用以下形式：

T&& ref

对于T一些推导类型。

例如，这是一个转发引用：

template <class T>
auto foo(T&& ref) -> void;

所有这些都是右值引用：

auto foo(int&& ref) -> void; // int not deduced

template <class T>
auto foo(const T&& ref); // not in form `T&&` (note the const)

template <class T>
auto foo(std::vector<T>&& ref) -> void; // not in form `T&&`

template <class T>
struct X {
    auto foo(T&& ref) -> T; // T not deduced. (It was deduced at class level)
};

更多信息请查看this excellent in-depth article by Scott Meyers，并注意在撰写本文时使用了“通用参考”一词（实际上是由斯科特本人介绍的）。现在一致认为“转发参考”更好地描述了它的目的和用法。

---

所以你的例子应该是：

ClassName(ClassName&& other)
   : _data(std::move(other._data))
{
}

因为other 是rvalue reference，因为ClassName 不是推导类型。

Answer 3

这个Ideone example 应该会让你很清楚。如果没有，请继续阅读。

以下构造函数仅接受右值。然而，由于参数“其他”得到了一个名称，它失去了它的“右值”，现在是一个左值。要将其转换回 Rvalue，您必须使用 std::move。这里没有理由使用std::forward，因为这个构造函数不接受左值。如果你试图用左值调用它，你会得到编译错误。

ClassName(ClassName&& other)
     : _data(std::move(other._data))
{
    // If you don't use move, you could have: 
    //    cout << other._data;
    // And you will notice "other" has not been moved.    
}

以下构造函数同时接受左值和右值。 Scott Meyers 将其称为“Universal Rerefences”，但现在称为“Forwarding References”。这就是为什么在这里必须使用 std::forward 以便如果 other 是 Rvalue，_data 构造函数将被 Rvalue 调用。如果 other 是左值，_data 将用左值构造。这就是为什么它被称为perfect-forwarding.

template<typename T>
ClassName(T&& other)
   : _data(std::forward<decltype(_data)>(other._data))
{
}

我尝试使用您的构造函数作为示例，以便您理解，但这并不特定于构造函数。这也适用于函数。

在第一个例子中，由于你的第一个构造函数只接受右值，你可以完美地使用std::forward，并且两者都会做同样的事情。但最好不要这样做，因为人们可能会认为你的构造函数接受了forwarding reference，而实际上并没有。