为什么通用参考的参数需要在使用之前进行转换？

Question

在lecture about universal references 中，Scott Meyers（大约在第 40 分钟）说，作为通用引用的对象在使用之前应该转换为真实类型。换句话说，只要有一个具有通用引用类型的模板函数，就应该在使用运算符和表达式之前使用std::forward，否则可能会复制该对象。

我对此的理解在以下示例中：

#include <iostream>

struct A
{
  A() { std::cout<<"constr"<<std::endl; }
  A(const A&) { std::cout<<"copy constr"<<std::endl; }
  A(A&&) { std::cout<<"move constr"<<std::endl; }
  A& operator=(const A&) { std::cout<<"copy assign"<<std::endl; return *this; }
  A& operator=(A&&) { std::cout<<"move assign"<<std::endl; return *this; }

  ~A() { std::cout<<"destr"<<std::endl; }

  void bar()
  {
    std::cout<<"bar"<<std::endl;
  }
};

A getA()
{
  A a;
  return a;
}

template< typename T >
void callBar( T && a )
{
  std::forward< T >( a ).bar();
}

int main()
{
  {
    std::cout<<"\n1"<<std::endl;
    A a;
    callBar( a );
  }

  {
    std::cout<<"\n2"<<std::endl;
    callBar( getA() );
  }
}

正如预期的那样，输出是：

1
constr
bar
destr

2
constr
move constr
destr
bar
destr

问题真的是为什么需要这样做？

std::forward< T >( a ).bar();

我尝试不使用 std::forward，它似乎工作正常（输出相同）。

同样，为什么他建议在带有右值的函数内部使用move？ （答案与 std::forward 相同）

void callBar( A && a )
{
  std::move(a).bar();
}

我知道std::move 和std::forward 都只是转换为适当的类型，但上述示例中真的需要这些转换吗？

奖励：如何修改示例以生成传递给该函数的对象的副本？

Answer 1

这是必需的，因为bar() 可能会分别为右值和左值重载。这意味着它可能会做一些不同的事情，或者完全不允许，这取决于您是否正确地将a 描述为左值或右值，或者只是盲目地将其视为左值。目前，大多数用户不使用此功能，也没有接触过它，因为最流行的编译器不支持它——甚至 GCC 4.8 也不支持右值 *this。但它是标准的。

Answer 2

&& 用于函数的参数有两种不同的用途。对于普通函数，这意味着参数是右值引用；对于模板函数，这意味着它可以是或者右值引用或左值引用：

template <class T> void f(T&&); // rvalue or lvalue
void g(T&&);                    // rvalue only
void g(T&)                      // lvalue only

void h() {
    C c;
    f(c);            // okay: calls f(T&)
    f(std::move(c)); // okay: calls f(T&&)
    g(c);            // error: c is not an rvalue
    g(std::move(c)); // okay: move turns c into an rvalue
}

在f 和g 中，将std::forward 应用于此类参数会保留参数的左值或右值，因此通常这是将参数转发给另一个函数的最安全方法。

Answer 3

void callBar( A && a )
{
  std::move(a).bar();
}

如果你有一个右值引用作为参数，它只能绑定到一个右值，你通常想使用移动语义从这个右值移动并取出它的胆量。

参数本身是一个左值，因为它是一个命名的东西。你可以拿它的地址。

因此，为了使其再次成为右值并能够从中移动，您将std::move 应用于它。如果您实际上只是在传递的参数上调用函数，我不明白为什么您会有一个作为右值引用的参数。

如果你要在你的函数内部移动，你只想传递一个右值引用，这就是为什么你必须使用std::move。

你的例子在这方面实际上没有多大意义。

Answer 4

讲座中说的是这样的：

void doWork( Widget&& param )
{
  ops and exprs using std::move(param)
}

SM：这意味着：如果您看到代码采用右值引用，并且您看到该参数的使用没有被 move 包装，那么这是高度可疑的。

经过一番思考，我意识到这是正确的（如预期的那样）。将原始示例中的callBar 函数更改为这说明了这一点：

void reallyCallBar( A& la )
{
  std::cout<<"lvalue"<<std::endl;
  la.bar();
}

void reallyCallBar( A&& ra )
{
  std::cout<<"rvalue"<<std::endl;
  ra.bar();
}

template< typename T >
void callBar( T && a )
{
  reallyCallBar( std::forward< T >( a ) );
}

如果std::forward 未在callBar 中使用，则将使用reallyCallBar( A& )。因为callBar 中的a 是左值引用。当通用引用是右值引用时，std::forward 使其成为右值。

下一个修改进一步证明了这一点：

void reallyCallBar( A& la )
{
  std::cout<<"lvalue"<<std::endl;
  la.bar();
}

void reallyCallBar( A&& ra )
{
  std::cout<<"rvalue"<<std::endl;
  reallyCallBar( ra );
}

template< typename T >
void callBar( T && a )
{
  reallyCallBar( std::forward< T >( a ) );
}

由于std::move没有在reallyCallBar( A&& ra )函数中使用，所以它不会进入死循环。相反，它调用采用左值引用的版本。

因此（如讲座中所述）：

• std::forward 必须用于通用引用
• std::move 必须用于右值引用