函数返回一个对象，在GCC和VC下的不同表现

hufeiyc

1. #include <cstdlib>
   
2. #include <iostream>
   
3. #include <string>
   
4. 
   
5. 
   
6. using namespace std;
   
7. 
   
8. class A {
   
9. public:
   
10. 
    
11.     A(int in = 0) : i(in) {
    
12.         cout << "int constructor: in value[" << in << "]" << endl;
    
13.     }
    
14. 
    
15.     A(A& inA)
    
16.     {
    
17.         cout << "copy constructor: in value[" << inA.getI() << "]" << endl;
    
18.         this->i = inA.getI();
    
19.     }
    
20. 
    
21.     ~A() {
    
22.     }
    
23. 
    
24.     void setI(int inI) {
    
25.         this->i = inI;
    
26.     }
    
27. 
    
28.     int getI() const {
    
29.         return this->i;
    
30.     }
    
31. 
    
32.     A operator*(const A& inA) {  //重载“乘”， 函数以值返回一个对象
    
33.         A _ans;
    
34.         _ans.setI(this->getI() * inA.getI());
    
35.         cout << "Fun  in: [" << &_ans << "]" << endl;
    
36.         return _ans;  //suppose调用copy构造函数， 返回临时对象
    
37.     }
    
38. public:
    
39.     int j;
    
40.     int i;
    
41. };
    
42. 
    
43. int main() {
    
44.     A a1(10);
    
45.     A a2(20);
    
46.     const A& ptr = a1 * a2;
    
47.     cout << "Fun out: [" << &ptr << "]" << endl;
    
48.     cout << ptr.i << endl;
    
49.     return 0;
    
50. }

复制代码

有一小段程序在VC下表现不一致

GCC output：
int constructor: in value[10]
int constructor: in value[20]
int constructor: in value[0]
Fun  in: [0xbfc0afc4]
Fun out: [0xbfc0afc4]
200

VC output
int constructor: in value[10]
int constructor: in value[20]
int constructor: in value[0]
Fun  in: [0xbfc78dc4]
copy constructor: in value[200]  <----调用了copy构造函数
Fun out: [0xbfc78de8]    <----不一样的地址
200


按照C++ primer里面讲的， VC的输出应该是最符合经典的。
但是GCC为什么有那样的输出？ 退出函数之后栈对象难道还能存活？

bruceteen

按照C++标准（而不是你说的什么C++ primer），临时对象的生存期一直到其引用结束为止。
比如 foo function() {……}
function(); // 返回的匿名临时对象到此语句结束时被释放
foo& f = function(); // 返回的匿名临时对象到f离开作用域后被释放

对于你的代码，g++的输出非常正常，没什么好说的；对于VC++，则是因为它没有能对“具名临时对象”做“返回值优化”，所以它多了个拷贝构造函数。

另外，你写的代码这个这个……，你原来是搞java的吧？！

hufeiyc

按照C++标准（而不是你说的什么C++ primer），临时对象的生存期一直到其引用结束为止。
比如 foo function ...
bruceteen 发表于 2011-03-19 08:52

C++ primer是本书啊...里面说reference延长了临时对象的生存期，以前一直任何返回一个对象会直接调用copy函数。
另外请问你对VC的解释具体是什么意思，不是很明白。

还有我以前啥也不搞，菜鸟刚学。

谢谢了

wangjl_sdu

这里实现的语义是一样的，只不过不同的编译器做法不同，我理解的GCC可能稍微只能一些。

在乘法的子函数里面，操作的对象实际上是调用它的函数(main)里面的局部变量。 我把dump出来的汇编贴上来

1. 
   
2. int main() {
   
3. 8048754:        8d 4c 24 04                  lea    0x4(%esp),%ecx
   
4. 8048758:        83 e4 f0                     and    $0xfffffff0,%esp
   
5. 804875b:        ff 71 fc                     pushl  -0x4(%ecx)
   
6. 804875e:        55                           push   %ebp
   
7. 804875f:        89 e5                        mov    %esp,%ebp
   
8. 8048761:        56                           push   %esi
   
9. 8048762:        53                           push   %ebx
   
10. 8048763:        51                           push   %ecx
    
11. 8048764:        83 ec 3c                     sub    $0x3c,%esp //GCC 预留了0x3c个byte的空间用作main的局部变量
    
12.     A a1(10);
    
13. 8048767:        c7 44 24 04 0a 00 00         movl   $0xa,0x4(%esp)
    
14. 804876e:        00
    
15. 804876f:        8d 45 dc                     lea    -0x24(%ebp),%eax   // a1就是ebp-24了
    
16. 8048772:        89 04 24                     mov    %eax,(%esp)
    
17. 8048775:        e8 76 01 00 00               call   80488f0 <_ZN1AC1Ei>
    
18.     A a2(20);
    
19. 804877a:        c7 44 24 04 14 00 00         movl   $0x14,0x4(%esp)
    
20. 8048781:        00
    
21. 8048782:        8d 45 d4                     lea    -0x2c(%ebp),%eax //a2就是 ebp-2c了
    
22. 8048785:        89 04 24                     mov    %eax,(%esp)
    
23. 8048788:        e8 63 01 00 00               call   80488f0 <_ZN1AC1Ei>
    
24.     const A& ptr = a1 * a2;
    
25. 804878d:        8d 45 cc                     lea    -0x34(%ebp),%eax //这是GCC生成的内部匿名对象，作为参数传递了
    
26. 8048790:        8d 55 d4                     lea    -0x2c(%ebp),%edx //a2
    
27. 8048793:        89 54 24 08                  mov    %edx,0x8(%esp)
    
28. 8048797:        8d 55 dc                     lea    -0x24(%ebp),%edx  //a1
    
29. 804879a:        89 54 24 04                  mov    %edx,0x4(%esp)
    
30. 804879e:        89 04 24                     mov    %eax,(%esp)
    
31. 80487a1:        e8 be 01 00 00               call   8048964 <_ZN1AmlERKS_>
    
32. 80487a6:        83 ec 04                     sub    $0x4,%esp
    
33. 80487a9:        8d 45 cc                     lea    -0x34(%ebp),%eax
    
34. 80487ac:        89 45 e4                     mov    %eax,-0x1c(%ebp)
    
35.     cout << "Fun out: [" << &ptr << "]" << endl;
    
36. 
    
37. 然后看乘法的代码
    
38. A operator*(const A& inA) {  //重载“乘”， 函数以值返回一个对象
    
39. 8048964:        55                           push   %ebp
    
40. 8048965:        89 e5                        mov    %esp,%ebp
    
41. 8048967:        57                           push   %edi
    
42. 8048968:        56                           push   %esi
    
43. 8048969:        53                           push   %ebx
    
44. 804896a:        83 ec 2c                     sub    $0x2c,%esp
    
45. 804896d:        8b 5d 08                     mov    0x8(%ebp),%ebx  //现在的ebp是原来的esp（也就是老的EBP-0x3c，所以现在ebx指向的就是main里面那个匿名对象。
    
46.         A _ans;
    
47. 8048970:        89 d8                        mov    %ebx,%eax 关键在这里，对局部变量进行构造的时候，GCC直接对main里面那个局部变量构造了。所以GCC省去了copy 构造这一步。
    
48. 8048972:        c7 44 24 04 00 00 00         movl   $0x0,0x4(%esp)
    
49. 8048979:        00
    
50. 804897a:        89 04 24                     mov    %eax,(%esp)
    
51. 804897d:        e8 6e ff ff ff               call   80488f0 <_ZN1AC1Ei>
    

复制代码

变异老鼠

虽然很多人可能会觉得非常不能接受，但是这的确是一个标准规定可以强制进行的优化。详见 C++98/03 12.2 的第 15 条。

简单地说就是函数返回一个具有自动生存期的对象的时候，或者一个没有绑定到引用的临时对象被用于另一个对象的 copy constructor 的时候，相应的复制都可以被省略掉。而不用管对象的 copy constructor 中到底做了什么事情。

hufeiyc

回复 4# wangjl_sdu


谢谢了 很helpful and informative

nizvoo

很好，很少返回对象啊。