返回值和右值引用的传递问题

测试类

　　测试类结构如下：

[cpp]  view plain  copy

1. class Test2  
2. {  
3. public:  
4.     Test2() {}  
5.     Test2(const char* str);  
6.     Test2(const Test2& o);  
7.     Test2(Test2&& o);  
8.     virtual ~Test2();  
9.     Test2& operator=(const Test2& o);  
10.     Test2& operator=(Test2&& o);  
11.     void swap(Test2& o);  
12.     const char* cstr() const { return _blocks ? _blocks : ""; }  
13. protected:  
14.     char* _blocks;  // 保存字符串的缓冲区  
15. };  

　　可以看到，这个类中包含了C++11标准中规定的若干元素：

• 默认构造函数（可缺省）；
• 参数构造函数（可缺省）；
• 析构函数；
• copy构造函数；
• move构造函数（转移构造函数）；
• copy赋值运算符；
• move赋值运算符（转移赋值运算）；
• 对象交换函数；

　　其中，关键的几个函数实现如下：

[cpp]  view plain  copy

1. /** 
2.  * 参数构造器 
3.  * @param [in] str 字符串值 
4.  */  
5. Test2::Test2(const char* str) :  
6.     _blocks(NULL)  
7. {  
8.     if (str)  
9.         _blocks = ::strdup(str);  
10. }  
11.   
12. /** 
13.  * 拷贝构造函数 
14.  * @param [in] o 同类型的另一个对象引用 
15.  */  
16. Test2::Test2(const Test2& o) :  
17.     _blocks(NULL)  
18. {  
19.     if (o._blocks)  
20.         _blocks = ::strdup(o._blocks);  
21. }  
22.   
23. /** 
24.  * Move构造函数 
25.  * @param [in] o 同类型的另一个对象右值引用 
26.  */  
27. Test2::Test2(Test2&& o) :  
28.     _blocks(NULL)  
29. {  
30.     swap(o);  
31. }  
32.   
33. /** 
34.  * 析构函数 
35.  */  
36. Test2::~Test2()  
37. {  
38.     if (_blocks)  
39.         ::free(_blocks);  
40.     _blocks = NULL;  
41. }  
42.   
43. /** 
44.  * 赋值运算符重载 
45.  * @param [in] o 同类型的另一个对象引用 
46.  * @return 当前类型的另一个引用 
47.  */  
48. Test2& Test2::operator=(const Test2& o)  
49. {  
50.     if (this != &o)  
51.         Test2(o, int()).swap(*this);  
52.     return *this;  
53. }  
54.   
55. /** 
56.  * 右值引用赋值运算符重载 
57.  * @param [in] o 同类型的另一个对象右值引用 
58.  * @return 当前类型的另一个引用 
59.  */  
60. Test2& Test2::operator=(Test2&& o)  
61. {  
62.     if (this != &o)  
63.     {  
64.         swap(o);  
65.         o.~Test2();  
66.     }  
67.     return *this;  
68. }  
69.   
70. /** 
71.  * 交换两个对象 
72.  * @param [in] o 同类型的另一个对象 
73.  */  
74. void Test2::swap(Test2& o)  
75. {  
76.     std::swap(_blocks, o._blocks);  
77. }  

　　突然想了解一下具有move构造函数和move赋值运算的类，在对象传递时会发生什么情况，所以写了下面的几个函数进行测试。

第一个函数，返回函数内部产生的局部变量：

[cpp]  view plain  copy

1. /** 
2.  * 测试返回内部具备变量 
3.  * @return 返回临时生成的对象 
4.  */  
5. Test2 return_object()  
6. {  
7.     Test2 res = "test";  
8.     return res;  
9. }  

通过如下代码测试

[cpp]  view plain  copy

1. Test2 t1 = return_object();  
2. t1 = return_object();  

结论：

1. 第一行代码中，只在调用函数内部执行了一次参数构造函数（构造局部对象），没有发生copy构造函数（或者move构造函数）的调用，即可以认为在函数内部实例化的局部对象就是返回值变量t1，这应该是编译器优化的结果；
2. 第二行代码执行时，变量t1已经被初始化，所以赋值运算是必然会发生的，此时除过在调用函数内部执行了一次参数构造函数（构造局部对象）外，还执行了一次move赋值运算，可见编译器认为函数的返回值是右值。由于有了move赋值运算符，所以没有调用copy赋值运算符，相当于将函数内部的局部对象（右值）转移到了t1变量（左值）中，完成了右到左的转化（减少了一次构造和析构）；

第二个函数，返回函数内部产生的局部变量的引用：

[cpp]  view plain  copy

1. /** 
2.  * 测试返回局部变量的引用 
3.  * @return 返回临时生成的对象的引用 
4.  */  
5. Test2& return_reference()  
6. {  
7.     Test2 res = "test";  
8.     return res;  
9. }  

　　这个函数一看就是 错误的，返回局部变量的引用或指针都是不允许的，因为在函数返回前，局部变量就会被析构，导致返回的引用是 无效引用（已经游离），为了测试的完整性，用如下代码测试：

[cpp]  view plain  copy

1. Test2 t2 = return_reference();  
2. t2 = return_reference();  

结论：

1. 第一行代码中，在调用函数内部执行了参数构造函数构造了局部对象，之后又执行了copy构造函数，其含义是将返回的局部对象引用，通过copy构造函数来构造变量t2对象，但结果是变量t2不一定可以构造成功，即使构造成功了其值也不正确，显然在调用copy构造函数的时候，局部对象已经析构，copy的值无效；
2. 第二行代码中，在调用函数内部执行了参数构造函数构造了局部对象，之后又执行了copy赋值函数，结果和第一行代码类似；

第三个函数，返回函数内部产生局部变量的右值引用：

[cpp]  view plain  copy

1. /** 
2.  * 测试返回局部变量的右值引用 
3.  * @return 返回临时生成的对象的右值引用 
4.  */  
5. Test2 return_right_reference()  
6. {  
7.     Test2 res = "test";  
8.     return std::move(res);<span style="white-space:pre;">   </span>// move函数在这里的作用是将res的引用类型转换为右值引用类型  
9. }  

　　以如下代码进行测试：

[cpp]  view plain  copy

1. Test2 t3 = return_right_reference();  
2. t3 = return_right_reference();  

结论：

1. 第一行代码中，除了调用参数构造函数构造局部对象外，还调用了一次move构造函数，这是由于返回值变成了局部对象的右值引用，和变量t3类型不同，所以又额外的调用了一次move构造函数对变量t3进行初始化；
2. 第二行代码中，情况就比较复杂了。照例通过参数构造函数构造了局部对象，但返回的是其右值引用，所以又调用了一次move构造函数，通过该右值引用产生了一个临时的Test2对象（右值对象），最后通过一个move赋值运算将临时的Test2对象转移给变量t3；

第四个函数，对第三个函数进行修改：

[cpp]  view plain  copy

1. /** 
2.  * 测试返回局部变量的右值引用 
3.  * @return 返回临时生成的对象的右值引用 
4.  */  
5. Test2&& return_right_reference2()  
6. {  
7.     Test2 res = "test";  
8.     return std::move(res);  // move函数在这里的作用是将res的引用类型转换为右值引用类型  
9. }  

结论：

　　这段代码执行的结果和“第二个函数”一样，返回局部变量的引用（不管是左值还是右值）都不会有正确结果。

总结：

　　最后发现，最朴素的写法反而是执行效率最高的写法（“第一个函数”），这种写法充分的利用了编译器在构造对象时进行的优化以及move赋值运算带来的优势，避免了对象在传递过程中产生的临时对象以及引发的构造和析构； 这也体现了move赋值运算存在的必要性。
　　 无论如何，都不能在函数内部返回临时变量的指针或引用，无论该引用是左值引用还是右值引用。C++11也从来没有认为变量的控制权被转移后析构就不再发生了。所以要在函数内部产生一个对象并返回，正确的做法是：1）将对象建立在堆内存上并返回地址；2）返回局部对象，并通过copy复制运算符在函数外复制该局部对象的副本；3）返回局部对象（是一个右值），并通过move复制运算符将返回的局部对象转移到另一个对象中；
　　 move函数不能乱用，C++在一些场合下，隐含着右值的概念（比如函数返回值就是右值），此时将值进行类型转换都会导致额外的不必要开销（例如将返回值必须是“右值”，如果将其转为“右值引用”，编译器仍要生成代码将其转回“右值”的对象，等于做了一堆无用功）。

　　上面这些结论在C++文档里说的很明白，但以前也从没有专门思考过，这次做一个测试，发现了一些没有发现的问题，特别是move赋值运算在传递返回值时的作用和move函数在返回时的无效性。所以有些东西光看文档是不够的，还得亲手试一下。