下文先从 C11 引入的几个规则，如引用折叠、右值引用的特殊类型推断规则、static_cast 的扩展功能说起，然后通过例子解析 std::move 和 std::forward 的推导解析过程，说明 std::move 和 std::forward 本质就是一个转换函数，std::move 执行到右值的无条件转换，std::forward 执行到右值的有条件转换，在参数都是右值时，二者就是等价的。其实 std::move 和 std::forward 就是在 C11 基本规则之上封装的语法糖。

1 引入的新规则

规则 1（引用折叠规则）：如果间接的创建一个引用的引用，则这些引用就会 “折叠”。在所有情况下（除了一个例外），引用折叠成一个普通的左值引用类型。一种特殊情况下，引用会折叠成右值引用，即右值引用的右值引用， T&& &&。即

  • X& &、X& &&、X&& & 都折叠成 X&
  • X&& && 折叠为 X&&

规则 2（右值引用的特殊类型推断规则）：当将一个左值传递给一个参数是右值引用的函数，且此右值引用指向模板类型参数 (T&&) 时，编译器推断模板参数类型为实参的左值引用，如

  1. template<typename T> 
  2. void f(T&&);
  4. int i = 42;
  5. f(i)

上述的模板参数类型 T 将推断为 int & 类型，而非 int。

若将规则 1 和规则 2 结合起来，则意味着可以传递一个左值int i给 f，编译器将推断出 T 的类型为 int&。再根据引用折叠规则 void f(int& &&) 将推断为 void f(int&)，因此，f 将被实例化为: void f(int&)。

从上述两个规则可以得出结论：如果一个函数形参是一个指向模板类型的右值引用，则该参数可以被绑定到一个左值上，即类似下面的定义：

  1. template<typename T> 
  2. void f(T&&);

规则 3：虽然不能隐式的将一个左值转换为右值引用，但是可以通过 static_cast 显示地将一个左值转换为一个右值。【C++11 中为 static_cast 新增的转换功能】。

2 std::move

2.1 std::move 的使用

  1. class Foo
  2. {
  3. public:
  4.     std::string member;
  6.     // Copy member.
  7.     Foo(const std::string& m): member(m) {}
  9.     // Move member.
  10.     Foo(std::string&& m): member(std::move(m)) {}
  11. };

上述Foo(std::string&& member)中的 member 是 rvalue reference，但是 member 却是一个左值 lvalue，因此在初始化列表中需要使用 std::move 将其转换成 rvalue。

2.2 std::move() 解析

标准库中 move 的定义如下：

  1. template<typename T>
  2. typename remove_reference<T>::type && move(T&& t)
  3. {
  4.     return static_cast<typename remove_reference<T>::type &&>(t);
  5. }
  • move 函数的参数 T&& 是一个指向模板类型参数的右值引用【规则 2】，通过引用折叠，此参数可以和任何类型的实参匹配，因此 move 既可以传递一个左值，也可以传递一个右值；
  • std::move(string(“hello”)) 调用解析：
    • 首先，根据模板推断规则，确地 T 的类型为 string;
    • typename remove_reference::type && 的结果为 string &&;
    • move 函数的参数类型为 string&&;
    • static_cast(t)，t 已经是 string&&，于是类型转换什么都不做，返回 string &&;
  • string s1(“hello”); std::move(s1); 调用解析：
    • 首先，根据模板推断规则，确定 T 的类型为 string&;
    • typename remove_reference::type && 的结果为 string&
    • move 函数的参数类型为 string& &&，引用折叠之后为 string&;
    • static_cast(t)，t 是 string&，经过 static_cast 之后转换为 string&&, 返回 string &&;

从 move 的定义可以看出，move 自身除了做一些参数的推断之外，返回右值引用本质上还是靠 static_cast 完成的。

因此下面两个调用是等价的，std::move 就是个语法糖。

  1. void func(int&& a)
  2. {
  3.     cout << a << endl;
  4. }
  6. int a = 6;
  7. func(std::move(a));
  9. int b = 10;
  10. func(static_cast<int&&>(b));

std::move 执行到右值的无条件转换。就其本身而言，它没有 move 任何东西。

3 std::forward()

3.1 完美转发

完美转发实现了参数在传递过程中保持其值属性的功能，即若是左值，则传递之后仍然是左值，若是右值，则传递之后仍然是右值。

C++11 lets us perform perfect forwarding, which means that we can forward the parameters passed to a function template to another function call inside it without losing their own qualifiers (const-ref, ref, value, rvalue, etc.).

3.2 std::forward() 解析

std::forward 只有在它的参数绑定到一个右值上的时候，它才转换它的参数到一个右值。

  1. class Foo
  2. {
  3. public:
  4.     std::string member;
  6.     template<typename T>
  7.     Foo(T&& member): member{std::forward<T>(member)} {}
  8. };

传递一个 lvalue 或者传递一个 const lvaue

  • 传递一个 lvalue，模板推导之后 T = std::string&
  • 传递一个 const lvaue, 模板推导之后T = const std::string&
  • T& &&将折叠为 T&，即std::string& && 折叠为 std::string&
  • 最终函数为: Foo(string& member): member{std::forward<string&>(member)} {}
  • std::forward(member) 将返回一个左值，最终调用拷贝构造函数

传递一个 rvalue

  • 传递一个 rvalue，模板推导之后 T = std::string
  • 最终函数为: Foo(string&& member): member{std::forward<string>(member)} {}
  • std::forward(member) 将返回一个右值，最终调用移动构造函数；

std::move 和 std::forward 本质都是转换。std::move 执行到右值的无条件转换。std::forward 只有在它的参数绑定到一个右值上的时候，才转换它的参数到一个右值。

std::move 没有 move 任何东西，std::forward 没有转发任何东西。在运行期，它们没有做任何事情。它们没有产生需要执行的代码，一 byte 都没有。

4 std::move() 和 std::forward() 对比

  • std::move 执行到右值的无条件转换。就其本身而言，它没有 move 任何东西。
  • std::forward 只有在它的参数绑定到一个右值上的时候，它才转换它的参数到一个右值。
  • std::move 和 std::forward 只不过就是执行类型转换的两个函数；std::move 没有 move 任何东西，std::forward 没有转发任何东西。在运行期，它们没有做任何事情。它们没有产生需要执行的代码，一 byte 都没有。
  • std::forward() 不仅可以保持左值或者右值不变，同时还可以保持 const、Lreference、Rreference、validate 等属性不变；

5 一个完整的例子

  1. #include <iostream>
  2. #include <type_traits>
  3. #include <typeinfo>
  4. #include <memory>
  5. using namespace std;
  7. struct A
  8. {
  9.     A(int&& n)
  10.     {
  11.         cout << "rvalue overload, n=" << n << endl;
  12.     }
  13.     A(int& n)
  14.     {
  15.         cout << "lvalue overload, n=" << n << endl;
  16.     }
  17. };
  19. class B
  20. {
  21. public:
  22.     template<class T1, class T2, class T3>
  23.     B(T1 && t1, T2 && t2, T3 && t3) :
  24.         a1_(std::forward<T1>(t1)),
  25.         a2_(std::forward<T2>(t2)),
  26.         a3_(std::forward<T3>(t3))
  27.     {
  29.     }
  30. private:
  31.     A a1_, a2_, a3_;
  32. };
  34. template <class T, class U>
  35. std::unique_ptr<T> make_unique1(U&& u)
  36. {
  37.     //return std::unique_ptr<T>(new T(std::forward<U>(u)));
  38.     return std::unique_ptr<T>(new T(std::move(u)));
  39. }
  41. template <class T, class... U>
  42. std::unique_ptr<T> make_unique(U&&... u)
  43. {
  44.     //return std::unique_ptr<T>(new T(std::forward<U>(u)...));
  45.     return std::unique_ptr<T>(new T(std::move(u)...));
  46. }
  48. int main()
  49. {
  50.     auto p1 = make_unique1<A>(2);
  52.     int i = 10;
  53.     auto p2 = make_unique1<A>(i);
  55.     int j = 100;
  56.     auto p3 = make_unique<B>(i, 2, j);
  57.     return 0;
  58. }

【本文编辑多次，在学习和实践过程中理解也逐渐加深，欢迎相互学习相互讨论】

参考