返回值优化问题

近来看到小李子写了篇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. //
4. #include "stdafx.h"
5. #include <iostream>
6. using namespace std;
7. class A
8. {
9. private:
10.     int a;
11. public:
12.     A(int a)
13.     {
14.         this->a = a;
15.     }
16.     ~A()
17.     {
18.         cout << "AA:"<<a<<endl;
19.     }
20. };
23. A& foo1(int c)
24. {
25.     return A(c);
26. }
29. A foo2(int c)
30. {
31.     return A(c);
32. }
34. A foo3(int c)
35. {
36.     A a(c);
37.     return a;
38. }
39. A& foo4(int c)
40. {
41.     A a(c);
42.     return a;
43. }
44. int _tmain(int argc, _TCHAR* argv[])
45. {
46.     foo1(1);
47.     cout <<"foo1"<<endl;
48.     foo2(2);
49.     cout <<"foo2"<<endl;
50.     foo3(3);
51.     cout <<"foo3"<<endl;
52.     foo4(4);
53.     cout <<"foo4"<<endl;
57.     A& a = foo1(1);
58.     A& b = foo2(2);
59.     A& c = foo3(3);
60.     A& d = foo4(4);
61.     return 0;
62. }

最后的运行结果是：

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的函数。