返回值优化问题

近来看到小李子写了篇blog，题目为返回值优化。

文章如下。

return Integer(left.i+right.i); //创建一个临时对象并返回他，不会调用析构函数，效率高。
Interger tmp(left.i+right.i);
return tmp;              //创建了局部对象，有析构函数。

————————————————————————————————

这里感觉有些诡异。

于是编写了简单的程序

1. // TempClassDestroy.cpp : Defines the entry point for the console application.
2. //
3. 4. #include “stdafx.h”
4. #include 
5. using namespace std;
6. class A
7. {
8. private :
9. int a;
10. public :
11. A( int a)
12. {
13. this ->a = a;
14. }
15. ~A()
16. {
17. cout << “AA:” <<a<<endl;
18. }
19. };
20. 22. 23. A& foo1( int c)
21. {
22. return A©;
23. }
24. 28. 29. A foo2( int c)
25. {
26. return A©;
27. }
28. 34. A foo3( int c)
29. {
30. A a©;
31. return a;
32. }
33. A& foo4( int c)
34. {
35. A a©;
36. return a;
37. }
38. int _tmain( int argc, _TCHAR* argv[])
39. {
40. foo1(1);
41. cout << “foo1” <<endl;
42. foo2(2);
43. cout << “foo2” <<endl;
44. foo3(3);
45. cout << “foo3” <<endl;
46. foo4(4);
47. cout << “foo4” <<endl;
48. 55. 56. 57. A& a = foo1(1);
49. A& b = foo2(2);
50. A& c = foo3(3);
51. A& d = foo4(4);
52. return 0;
53. }
54. 64. 最后的运行结果是：

AA:1
foo1
AA:2
foo2
AA:3
AA:3
foo3
AA:4
foo4
AA:1
AA:3
AA:4
AA:3
AA:2

当然前面的内容：

AA:1
foo1
AA:2
foo2
AA:3
AA:3
foo3
AA:4
foo4

第二个函数与第三个函数可以很明显的看到效率的差异。因为foo3函数中析构函数出现了两次。

（这里第一和第四个函数有明显错误，可以根据后面的测试程序看出）

但是第一个函数也恰恰说明 return Integer(left.i+right.i); //创建一个临时对象并返回他，不会调用析构函数，效率高。
这句话有些问题。因为在调试的时候可以看出有调用析构函数。并且结果

AA:1
AA:3
AA:4
AA:3
AA:2

也能说明问题。

由于第一个函数和第四个函数产生的效果一样。

所以我提出一个可能的假设：

return Integer(left.i+right.i);
只有当返回值为Integer，而非Integer&才能有创建一个临时对象并返回他，不会调用析构函数。

当然因为程序的正确性要求，我们不可能编写类似于foo1的函数。