[C/C++]关于C++11中的std::move和std::forward

http://www.cnblogs.com/cbscan/archive/2012/01/10/2318482.html

http://blog.csdn.net/fcryuuhou/article/details/8568194

 

std::move是一个用于提示优化的函数，过去的c++98中，由于无法将作为右值的临时变量从左值当中区别出来，所以程序运行时有大量临时变量白白的创建后又立刻销毁，其中又尤其是返回字符串std::string的函数存在最大的浪费。

比如：

1 std::string fileContent = “oldContent”;
2 s = readFileContent(fileName);

因为并不是所有情况下，C++编译器都能进行返回值优化，所以，向上面的例子中，往往会创建多个字符串。readFileContent如果没有内部状态，那么，它的返回值多半是std::string（const std::string的做法不再被推荐了），而不是const std::string&。这是一个浪费，函数的返回值被拷贝到s中后，栈上的临时对象就被销毁了。

在C++11中，编码者可以主动提示编译器，readFileContent返回的对象是临时的，可以被挪作他用：std::move。

将上面的例子改成：

1 std::string fileContent = “oldContent”;
2 s = std::move(readFileContent(fileName));

后，对象s在被赋值的时候，方法std::string::operator =(std::string&&)会被调用，符号&&告诉std::string类的编写者，传入的参数是一个临时对象，可以挪用其数据，于是std::string::operator =(std::string&&)的实现代码中，会置空形参，同时将原本保存在中形参中的数据移动到自身。

不光是临时变量，只要是你认为不再需要的数据，都可以考虑用std::move移动。

比较有名的std::move用法是在swap中：

1 template<typename T>
2 void swap(T& a, T& b)
3 {
4     T t(std::move(a));  // a为空，t占有a的初始数据
5     a = std::move(b); //  b为空， a占有b的初始数据
6     b = std::move(t); // t为空，b占有a的初始数据
7 } 

总之，std::move是为性能而生的，正式因为了有了这个主动报告废弃物的设施，所以C++11中的STL性能大幅提升，即使C++用户仍然按找旧有的方式来编码，仍然能因中新版STL等标准库的强化中收益。

 

std::forward是用于模板编程中的，如果不需要编写通用的模板类和函数，可能不怎么用的上它。

要认识它的作用，需要知道C++中的几条规则：（这里有篇挺好的文章：http://blog.csdn.net/zwvista/article/details/6848582，但似乎因标准的更新，其中的规则已不完全成立了）

1. 引用折叠规则：

X& + & => X&
X&& + & => X&
X& + && => X&
X&& + && => X&&

2. 对于模板函数中的形参声明T&&（这里的模板参数T，最终推演的结果可能不是一个纯类型，它可能还会带有引用/常量修饰符，如，T推演为const int时，实际形参为const int &&），会有如下规则：

如果调用函数时的实参为U&（这里的U可能有const/volatile修饰，但没有左/右引用修饰了），那么T推演为U&，显然根据上面的引用折叠规则，U& &&=>U&。

如果调用实参为U&&，虽然将T推导为U&&和U都能满足折叠规则（U&& &&=> U&&且U &&=>U&&），但标准规定，这里选择将T推演为U而非U&&。

总结一下第2条规则：当形参声明为T&&时，对于实参U&，T被推演为U&；当实参是U&&时，T被推演为U。当然，T和U具有相同的const/volatile属性。

3.这点很重要，也是上面zwvista的文章中没有提到的：形参T&& t中的变量t，始终是左值引用，即使调用函数的实参是右值引用也不例外。可以这么理解，本来，左值和右值概念的本质区别就是，左值是用户显示声明或分配内存的变量，能够直接用变量名访问，而右值主要是临时变量。当一个临时变量传入形参为T&& t的模板函数时，T被推演为U，参数t所引用的临时变量因为开始能够被据名访问了，所以它变成了左值。这也就是std::forward存在的原因！当你以为实参是右值所以t也应该是右值时，它跟你开了个玩笑，它是左值！如果你要进一步调用的函数会根据左右值引用性来进行不同操作，那么你在将t传给其他函数时，应该先用std::forward恢复t的本来引用性，恢复的依据是模板参数T的推演结果。虽然t的右值引用行会退化，变成左值引用，但根据实参的左右引用性不同，T会被分别推演为U&和U，这就是依据！因此传给std::forward的两个参数一个都不能少：std::forward<T>(t)。

 

再来，讨论一下，一个模板函数如果要保留参数的左右值引用性，为什么应该声明为T&&：

如果声明函数f(T t)：实参会直接进行值传递，失去了引用性。

如果声明函数f(T &t): 根据引用折叠法则，无论T是U&还是U&&，T&的折叠结果都只会是U&，即，这个声明不能用于匹配右值引用实参。

如果声明函数f(T &&t): 如果T为U&，T&&的结果是U&，可以匹配左值实参；如果T为U&&，T&&的结果是U&&，可以匹配右值实参。又因为T的cv性和U相同，所以这种声明能够保留实参的类型信息。

 

先来看一组帮助类：

1 template<typename T> struct TypeName { static const char *get(){ return "Type"; } };
2 template<typename T> struct TypeName<const T> { static const char *get(){ return "const Type"; } };
3 template<typename T> struct TypeName<T&> { static const char *get(){ return "Type&"; } };
4 template<typename T> struct TypeName<const T&> { static const char *get(){ return "const Type&"; } };
5 template<typename T> struct TypeName<T&&> { static const char *get(){ return "Type&&"; } };
6 template<typename T> struct TypeName<const T&&> { static const char *get(){ return "const Type&&"; } };

在模板函数内部将模板参数T传给TypeName，就可以访问T的类型字符串：TypeName<T>::get()。

 

再一个帮助函数，用于打印一个表达式的类型：

1 template<typename T>
2 void printValType(T &&val)
3 {
4     cout << TypeName<T&&>::get() << endl;
5 }

注意3条规则在这个模板函数上的应用。规则1，解释了T&& val的声明足以保留实参的类型信息。规则2，说明了，当实参是string&时，T就是string&；当实参是const string&&时，T就是const string（而非const string&&）。规则3，强调，无论实参是string&还是string&&，形参val的类型都是string&!

注意TypeName<T&&>的写法，因为T只能为U&或者U，显然T&&可以根据折叠法则还原为实参类型U&和U&&。

 

这里是常见的const/左右引用组合的情形：

1 class A{}; // 测试类
2 A& lRefA() { static A a; return a;} // 左值
3 const A& clRefA() { static A a; return a;} // 常左值
4 A rRefA() { return A(); } // 右值
5 const A crRefA() { return A(); } // 常右值

测试一下上面的表达式类型：

1 printValType(lRefA());
2 printValType(clRefA());
3 printValType(rRefA());
4 printValType(crRefA());

输出依次是： Type&，const Type&，Type&&，const Type&&。

 

现在正式来探讨std::forward的实现。

回顾一下使用std::forward的原因：由于声明为f(T&& t)的模板函数的形参t会失去右值引用性质，所以在将t传给更深层函数前，可能会需要回复t的正确引用行，当然，修改t的引用性办不到，但根据t返回另一个引用还是可以的。恰好，上面的函数printValType是一个会根据实参类型不同，作出不同反映的函数，所以可以把它作为f的内层函数，来检测f有没有正确的修正t的引用行。

 1 template<typename T>
 2 void f(T &&a)
 3 {
 4     printValType(a);
 5 }
 6 
 7 int main()
 8 {
 9     f(lRefA());
10     f(clRefA());
11     f(rRefA());
12     f(crRefA());
13 }

输出：Type&，const Type&，Type&，const Type&。

可见后两个输出错了，这正是前面规则3描述的，当实参是右值引用时，虽然T被推演为U，但是参数a退化成了左值引用。

直接应用std::forward：

1 template<typename T>
2 void f(T &&a)
3 {
4     printValType(std::forward<T>(a));
5 }

输出：Type&，const Type&，Type&&，const Type&&。

输出正确了，这就是std::forward的作用啊。如果更深层的函数也需要完整的引用信息，如这里的printValType，那就应该在传递形参前先std::forward！

 

在编写自己的forward函数之前，先来尝试直接强制转化参数a：

 template<typename T>
 void f(T &&a)
 {
     printValType((T&&)a);
 }

输出：Type&，const Type&，Type&&，const Type&&。

正确！因为不管T被推演为U&还是U，只要T&&肯定能还原为U&和U&&。

 

考虑下自己的forward函数应该怎么写：

 因为在forward的调用方中，形参已经丢失了右值引用信息，唯一的参考依据是T，要根据T还原为正确的参数，得T&&，因此，强制转换和返回类型都是T&&了，当然，forward还必须被以forward<T>()的方式显示指定模板类型，这样才能保证forward的模板参数T和上层函数f的T是相同类型。首先：

 template<typename T>
 T&& forward(... a)
 {
     return (T&&)a;
 }

调用方f一定得显示指定类型forward<T>。

形参怎么写？形参a的类型由T构成，而且forward的实参一定是左值（暂时不考虑forward(std::string())的使用方法），也就是说，无论T是U&还是U，形参a的类型一定都得是U&，才能和实参匹配，所以，结果是：

 template<typename T>
 T&& forward(T& a)
 {
     return (T&&)a;
 }

测试，输出：Type&，const Type&，Type&&，const Type&&。
正确！

 

再试下，如果f调用forward的时候，使用forward(a)的方式，没有显示指定模板类型会怎么样：

 template<typename T>
 void f(T &&a)
 {
     printValType(forward(a));
 }

输出：T&&，const Type&&，Type&&，const Type&&。

错了。分析下，因为实参始终是左值，所以forward的形参T& a中，T就被推演为U，因此(T&&)a也就是(U&&)a所以结果错误。

为了避免用户使用forward(a)，因此应该禁用forward的自动模板参数推演功能！可以借助std::identity，另外，将(T&&)换成static_cast<T&&>，规范一下：

 template<typename T>
 T&& forward(typename std::identity<T>::type& a)
 {
     return static_cast<T&&>(a);
 }

 

上面讲的是针对T为U&或U，而实参始终为左值的情况，这是常见的情形；不过也有实参为右值的情况，还需要改进上面这个forward，但我这里就不写了。

这是我手里的gcc4.5.2的forward实现：

    /// forward (as per N2835)
  /// Forward lvalues as rvalues.
    template<typename _Tp>
      inline typename enable_if<!is_lvalue_reference<_Tp>::value, _Tp&&>::type
      forward(typename std::identity<_Tp>::type& __t)
      { return static_cast<_Tp&&>(__t); }

    /// Forward rvalues as rvalues.
    template<typename _Tp>
     inline typename enable_if<!is_lvalue_reference<_Tp>::value, _Tp&&>::type
     forward(typename std::identity<_Tp>::type&& __t)
     { return static_cast<_Tp&&>(__t); }

   // Forward lvalues as lvalues.
   template<typename _Tp>
     inline typename enable_if<is_lvalue_reference<_Tp>::value, _Tp>::type
     forward(typename std::identity<_Tp>::type __t)
     { return __t; }

   // Prevent forwarding rvalues as const lvalues.
   template<typename _Tp>
     inline typename enable_if<is_lvalue_reference<_Tp>::value, _Tp>::type
     forward(typename std::remove_reference<_Tp>::type&& __t) = delete;

第1/3版本就相当于我之前的实现，而版本2/4是实参为右值的情况，至于后者这种取舍的原因，还得去自己研究下使用场合和文档了。

我手里的vc2010实现的forward和我之前的实现相同，显然还不够，不过vc2010本来对标准也就还支持得少...