C++ std::move和std::forward源码分析

深碍√TFBOYSˉ_ 2022-06-12 00:59 282阅读 0赞

http://blog.csdn.net/zwvista/article/details/6848582

std::move和std::forward是C++0x中新增的标准库函数，分别用于实现移动语义和完美转发。

下面让我们分析一下这两个函数在gcc4.6中的具体实现。

### 预备知识 ###

1.  引用折叠规则：  
    X& + & => X&  
    X&& + & => X&  
    X& + && => X&  
    X&& + && => X&&  
    
2.  函数模板参数推导规则（右值引用参数部分）：  
    当函数模板的模板参数为T而函数形参为T&&（右值引用）时适用本规则。  
    若实参为左值 U& ，则模板参数 T 应推导为引用类型 U& 。  
    （根据引用折叠规则， U& + && => U&， 而T&& ≡ U&，故T ≡ U& ）  
    若实参为右值 U&& ，则模板参数 T 应推导为非引用类型 U 。  
    （根据引用折叠规则， U或U&& + && => U&&， 而T&& ≡ U&&，故T ≡ U或U&&，这里强制规定T ≡ U ）  
    
3.  std::remove\_reference为C++0x标准库中的元函数，其功能为去除类型中的引用。  
    std::remove\_reference<U&>::type ≡ U  
    std::remove\_reference<U&&>::type ≡ U  
    std::remove\_reference<U>::type ≡ U  
    
4.  以下语法形式将把表达式 t 转换为T类型的右值（准确的说是无名右值引用，是右值的一种）  
    static\_cast<T&&>(t)
5.  无名的右值引用是右值  
    具名的右值引用是左值。
6.  注：本文中 ≡ 含义为“即，等价于“。

### std::move ###

函数功能

> std::move(t) 负责将表达式 t 转换为右值，使用这一转换意味着你不再关心 t 的内容，它可以通过被移动（窃取）来解决移动语意问题。

源码与测试代码

**\[cpp\]** [view plain][] [copy][view plain]

[print][view plain] [?][view plain]

1.  **template**<**typename** \_Tp> 
2.  **inline****typename** std::remove\_reference<\_Tp>::type&& 
3.   move(\_Tp&& \_\_t) 
4.   \{ **return****static\_cast**<**typename** std::remove\_reference<\_Tp>::type&&>(\_\_t); \}

**\[cpp\]** [view plain][] [copy][view plain]

[print][view plain] [?][view plain]

1.  \#include<iostream>
2.  **using****namespace** std; 
3.  
4.  **struct** X \{\}; 
5.  
6.  **int** main() 
7.  \{ 
8.   X a; 
9.   X&& b = move(a); 
10.  X&& c = move(X()); 
11. \}

代码说明

1.  测试代码第9行用X类型的左值 a 来测试move函数，根据标准X类型的右值引用 b 只能绑定X类型的右值，所以 move(a) 的返回值必然是X类型的右值。
2.  测试代码第10行用X类型的右值 X() 来测试move函数，根据标准X类型的右值引用 c 只能绑定X类型的右值，所以 move(X()) 的返回值必然是X类型的右值。
3.  首先我们来分析 move(a) 这种用左值参数来调用move函数的情况。
4.  模拟单步调用来到源码第3行，\_Tp&& ≡ X&, \_\_t ≡ a 。  
    
5.  根据函数模板参数推导规则，\_Tp&& ≡ X& 可推出 \_Tp ≡ X& 。  
    
6.  typename std::remove\_reference<\_Tp>::type ≡ X 。  
    typename std::remove\_reference<\_Tp>::type&& ≡ X&& 。
7.  再次单步调用进入move函数实体所在的源码第4行。
8.  static\_cast<typename std::remove\_reference<\_Tp>::type&&>(\_\_t) ≡ static\_cast<X&&>(a)
9.  根据标准 static\_cast<X&&>(a) 将把左值 a 转换为X类型的无名右值引用。
10. 然后我们再来分析 move(X()) 这种用右值参数来调用move函数的情况。
11. 模拟单步调用来到源码第3行，\_Tp&& ≡ X&&, \_\_t ≡ X() 。
12. 根据函数模板参数推导规则，\_Tp&& ≡ X&& 可推出 \_Tp ≡ X 。  
    
13. typename std::remove\_reference<\_Tp>::type ≡ X 。  
    typename std::remove\_reference<\_Tp>::type&& ≡ X&& 。
14. 再次单步调用进入move函数实体所在的源码第4行。
15. static\_cast<typename std::remove\_reference<\_Tp>::type&&>(\_\_t) ≡ static\_cast<X&&>(X())
16. 根据标准 static\_cast<X&&>(X()) 将把右值 X() 转换为X类型的无名右值引用。
17. 由9和16可知源码中std::move函数的具体实现符合标准，  
    因为无论用左值a还是右值X()做参数来调用std::move函数，  
    该实现都将返回无名的右值引用（右值的一种），符合标准中该函数的定义。

### std::forward ###

函数功能

> std::forward<T>(u) 有两个参数：T 与 u。当T为左值引用类型时，u将被转换为T类型的左值，否则u将被转换为T类型右值。如此定义std::forward是为了在使用右值引用参数的函数模板中解决参数的完美转发问题。

源码与测试代码

**\[cpp\]** [view plain][] [copy][view plain]

[print][view plain] [?][view plain]

1.  /// forward (as per N3143)
2.  **template**<**typename** \_Tp> 
3.  **inline** \_Tp&& 
4.   forward(**typename** std::remove\_reference<\_Tp>::type& \_\_t) 
5.   \{ **return****static\_cast**<\_Tp&&>(\_\_t); \} 
6.  
7.  **template**<**typename** \_Tp> 
8.  **inline** \_Tp&& 
9.   forward(**typename** std::remove\_reference<\_Tp>::type&& \_\_t) 
10.  \{ 
11.  static\_assert(!std::is\_lvalue\_reference<\_Tp>::value, "template argument"
12. " substituting \_Tp is an lvalue reference type"); 
13. **return****static\_cast**<\_Tp&&>(\_\_t); 
14.  \}

**\[cpp\]** [view plain][] [copy][view plain]

[print][view plain] [?][view plain]

1.  \#include<iostream>
2.  **using****namespace** std; 
3.  
4.  **struct** X \{\}; 
5.  **void** inner(**const** X&) \{cout << "inner(const X&)" << endl;\} 
6.  **void** inner(X&&) \{cout << "inner(X&&)" << endl;\} 
7.  **template**<**typename** T> 
8.  **void** outer(T&& t) \{inner(forward<T>(t));\} 
9.  
10. **int** main() 
11. \{ 
12.  X a; 
13.  outer(a); 
14.  outer(X()); 
15.  inner(forward<X>(X())); 
16. \} 
17. //inner(const X&)
18. //inner(X&&)
19. //inner(X&&)

代码说明

1.  测试代码第13行用X类型的左值 a 来测试forward函数，程序输出表明 outer(a) 调用的是 inner(const X&) 版本，从而证明函数模板outer调用forward函数在将参数左值 a 转发给了inner函数时，成功地保留了参数 a 的左值属性。
2.  测试代码第14行用X类型的右值 X() 来测试forward函数，程序输出表明 outer(X()) 调用的是 inner(X&&) 版本，从而证明函数模板outer调用forward函数在将参数右值 X() 转发给了inner函数时，成功地保留了参数 X() 的右值属性。
3.  首先我们来分析 outer(a) 这种调用forward函数转发左值参数的情况。
4.  模拟单步调用来到测试代码第8行，T&& ≡ X&, t ≡ a 。  
    
5.  根据函数模板参数推导规则，T&& ≡ X& 可推出 T ≡ X& 。  
    
6.  forward<T>(t) ≡ forward<X&>(t)，其中 t 为指向 a 的左值引用。  
    
7.  再次单步调用进入forward函数实体所在的源码第4行或第9行。  
    
8.  先尝试匹配源码第4行的forward函数，\_Tp ≡ X& 。
9.  typename std::remove\_reference<\_Tp>::type ≡ X 。  
    typename std::remove\_reference<\_Tp>::type& ≡ X& 。
10. 形参 \_\_t 与实参 t 类型相同，因此函数匹配成功。
11. 再尝试匹配源码第9行的forward函数，\_Tp ≡ X& 。
12. typename std::remove\_reference<\_Tp>::type ≡ X 。  
    typename std::remove\_reference<\_Tp>::type&& ≡ X&& 。
13. 形参 \_\_t 与实参 t 类型不同，因此函数匹配失败。
14. 由10与13可知7单步调用实际进入的是源码第4行的forward函数。
15. static\_cast<\_Tp&&>(\_\_t) ≡ static\_cast<X&>(t) ≡ a。
16. inner(forward<T>(t)) ≡ inner(static\_cast<X&>(t)) ≡ inner(a) 。
17. outer(a) ≡ inner(forward<T>(t)) ≡ inner(a)  
    再次单步调用将进入测试代码第5行的inner(const X&) 版本，左值参数转发成功。
18. 然后我们来分析 outer(X()) 这种调用forward函数转发右值参数的情况。
19. 模拟单步调用来到测试代码第8行，T&& ≡ X&&, t ≡ X() 。
20. 根据函数模板参数推导规则，T&& ≡ X&& 可推出 T ≡ X 。  
    
21. forward<T>(t) ≡ forward<X>(t)，其中 t 为指向 X() 的右值引用。  
    
22. 再次单步调用进入forward函数实体所在的源码第4行或第9行。
23. 先尝试匹配源码第4行的forward函数，\_Tp ≡ X 。
24. typename std::remove\_reference<\_Tp>::type ≡ X 。  
    typename std::remove\_reference<\_Tp>::type& ≡ X& 。
25. 形参 \_\_t 与实参 t 类型相同，因此函数匹配成功。
26. 再尝试匹配源码第9行的forward函数，\_Tp ≡ X 。
27. typename std::remove\_reference<\_Tp>::type ≡ X 。  
    typename std::remove\_reference<\_Tp>::type&& ≡ X&& 。
28. 形参 \_\_t 与实参 t 类型不同，因此函数匹配失败。
29. 由25与28可知22单步调用实际进入的仍然是源码第4行的forward函数。  
    
30. static\_cast<\_Tp&&>(\_\_t) ≡ static\_cast<X&&>(t) ≡ X()。
31. inner(forward<T>(t)) ≡ inner(static\_cast<X&&>(t)) ≡ inner(X())。
32. outer(X()) ≡ inner(forward<T>(t)) ≡ inner(X())  
    再次单步调用将进入测试代码第6行的inner(X&&) 版本，右值参数转发成功。  
    
33. 由17和32可知源码中std::forward函数的具体实现符合标准，  
    因为无论用左值a还是右值X()做参数来调用带有右值引用参数的函数模板outer，  
    只要在outer函数内使用std::forward函数转发参数，  
    就能保留参数的左右值属性，从而实现了函数模板参数的完美转发。

[view plain]: http://blog.csdn.net/zwvista/article/details/6848582#