C++11中std::forward的使用 (转)

std::forward argument: Returns an rvalue reference to arg if arg is not an lvalue reference; If arg is an lvalue reference, the function returns arg without modifying its type.

std::forward:This is a helper function to allow perfect forwarding of arguments taken as rvalue references to deduced types, preserving any potential move semantics involved.

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

std::move是无条件的转为右值引用，而std::forward是有条件的转为右值引用，更准确的说叫做Perfect forwarding(完美转发)，而std::forward里面蕴含着的条件则是Reference Collapsing(引用折叠)。

std::move不move任何东西。std::forward也不转发任何东西。在运行时，他们什么都不做。不产生可执行代码，一个比特的代码也不产生。

std::move和std::forward只是执行转换的函数(确切的说应该是函数模板)。std::move无条件的将它的参数转换成一个右值，而std::forward当特定的条件满足时，才会执行它的转换。

std::move表现为无条件的右值转换，就其本身而已，它不会移动任何东西。 std::forward仅当参数被右值绑定时，才会把参数转换为右值。 std::move和std::forward在运行时不做任何事情。

下面是从其他文章中copy的测试代码，详细内容介绍可以参考对应的reference：

[cpp] view plain copy

1. #include "forward.hpp"
2. #include <utility>
3. #include <iostream>
4. #include <memory>
5. #include <string>
6. //////////////////////////////////////////////
7. // reference: http://en.cppreference.com/w/cpp/utility/forward
8. struct A {
9. A(int&& n) { std::cout << "rvalue overload, n=" << n << "\n"; }
10. A(int& n)  { std::cout << "lvalue overload, n=" << n << "\n"; }
11. };
12. class B {
13. public:
14. template<class T1, class T2, class T3>
15. B(T1&& t1, T2&& t2, T3&& t3) :
16. a1_{ std::forward<T1>(t1) },
17. a2_{ std::forward<T2>(t2) },
18. a3_{ std::forward<T3>(t3) }
19. {
20. }
21. private:
22. A a1_, a2_, a3_;
23. };
24. template<class T, class U>
25. std::unique_ptr<T> make_unique1(U&& u)
26. {
27. return std::unique_ptr<T>(new T(std::forward<U>(u)));
28. }
29. template<class T, class... U>
30. std::unique_ptr<T> make_unique(U&&... u)
31. {
32. return std::unique_ptr<T>(new T(std::forward<U>(u)...));
33. }
34. int test_forward1()
35. {
36. auto p1 = make_unique1<A>(2); // rvalue
37. int i = 1;
38. auto p2 = make_unique1<A>(i); // lvalue
39. std::cout << "B\n";
40. auto t = make_unique<B>(2, i, 3);
41. return 0;
42. }
43. ////////////////////////////////////////////////////////
44. // reference: http://www.cplusplus.com/reference/utility/forward/
45. // function with lvalue and rvalue reference overloads:
46. void overloaded(const int& x) { std::cout << "[lvalue]"; }
47. void overloaded(int&& x) { std::cout << "[rvalue]"; }
48. // function template taking rvalue reference to deduced type:
49. template <class T> void fn(T&& x) {
50. overloaded(x);                   // always an lvalue
51. overloaded(std::forward<T>(x));  // rvalue if argument is rvalue
52. }
53. int test_forward2()
54. {
55. int a;
56. std::cout << "calling fn with lvalue: ";
57. fn(a);
58. std::cout << ‘\n‘;
59. std::cout << "calling fn with rvalue: ";
60. fn(0);
61. std::cout << ‘\n‘;
62. return 0;
63. }
64. //////////////////////////////////////////////////////
65. // reference: http://stackoverflow.com/questions/8526598/how-does-stdforward-work
66. template<class T>
67. struct some_struct{
68. T _v;
69. template<class U>
70. some_struct(U&& v) : _v(static_cast<U&&>(v)) {} // perfect forwarding here
71. // std::forward is just syntactic sugar for this
72. };
73. int test_forward3()
74. {
75. /* remember the reference collapsing rules(引用折叠规则):
76. 前者代表接受类型，后者代表进入类型，=>表示引用折叠之后的类型，即最后被推导决断的类型
77. TR   R
78. T&   &->T&   // lvalue reference to cv TR -> lvalue reference to T
79. T&   &&->T&  // rvalue reference to cv TR -> TR (lvalue reference to T)
80. T&&  &->T&   // lvalue reference to cv TR -> lvalue reference to T
81. T&&  &&->T&& // rvalue reference to cv TR -> TR (rvalue reference to T) */
82. some_struct<int> s1(5);
83. // in ctor: ‘5‘ is rvalue (int&&), so ‘U‘ is deduced as ‘int‘, giving ‘int&&‘
84. // ctor after deduction: ‘some_struct(int&& v)‘ (‘U‘ == ‘int‘)
85. // with rvalue reference ‘v‘ bound to rvalue ‘5‘
86. // now we ‘static_cast‘ ‘v‘ to ‘U&&‘, giving ‘static_cast<int&&>(v)‘
87. // this just turns ‘v‘ back into an rvalue
88. // (named rvalue references, ‘v‘ in this case, are lvalues)
89. // huzzah, we forwarded an rvalue to the constructor of ‘_v‘!
90. // attention, real magic happens here
91. int i = 5;
92. some_struct<int> s2(i);
93. // in ctor: ‘i‘ is an lvalue (‘int&‘), so ‘U‘ is deduced as ‘int&‘, giving ‘int& &&‘
94. // applying the reference collapsing rules yields ‘int&‘ (& + && -> &)
95. // ctor after deduction and collapsing: ‘some_struct(int& v)‘ (‘U‘ == ‘int&‘)
96. // with lvalue reference ‘v‘ bound to lvalue ‘i‘
97. // now we ‘static_cast‘ ‘v‘ to ‘U&&‘, giving ‘static_cast<int& &&>(v)‘
98. // after collapsing rules: ‘static_cast<int&>(v)‘
99. // this is a no-op, ‘v‘ is already ‘int&‘
100. // huzzah, we forwarded an lvalue to the constructor of ‘_v‘!
101. return 0;
102. }
103. ////////////////////////////////////////////////////
104. // reference: https://oopscenities.net/2014/02/01/c11-perfect-forwarding/
105. void sum(int a, int b)
106. {
107. std::cout << a + b << std::endl;
108. }
109. void concat(const std::string& a, const std::string& b)
110. {
111. std::cout<< a + b << std::endl;
112. }
113. void successor(int a, int& b)
114. {
115. b = ++a;
116. }
117. template <typename PROC, typename A, typename B>
118. void invoke(PROC p, A&& a, B&& b)
119. {
120. p(std::forward<A>(a), std::forward<B>(b));
121. }
122. int test_forward4()
123. {
124. invoke(sum, 10, 20);
125. invoke(concat, "Hello", "world");
126. int s = 0;
127. invoke(successor, 10, s);
128. std::cout << s << std::endl;
129. return 0;
130. }

GitHub：https://github.com/fengbingchun/Messy_Test