等号赋值的对象为什么销毁不调用析构函数呢？

ppm10103

Stock.cpp

1. 
   
2. #include "Stock.h"
   
3. #include <string>
   
4. #include <iostream>
   
5. 
   
6. using namespace std;
   
7. 
   
8. Stock::Stock(string name, double price) {
   
9.     cout << "with param constractor" << endl;
   
10.     Stock::m_name = name;
    
11.     Stock::m_price = price;
    
12. 
    
13. }
    
14. 
    
15. Stock::Stock(double price) {
    
16.     Stock::m_name = "defautl name";
    
17.     Stock::m_price = price;
    
18.     cout << "with param constractor" << endl;
    
19. }
    
20. 
    
21. Stock::Stock() {
    
22.     cout << "with no param constractor" << endl;
    
23. }
    
24. 
    
25. Stock::~Stock() {
    
26.     cout << "destory stock name:" << Stock::m_name << " ByeBye!" << endl;
    
27. }
    
28. 
    

复制代码

1. 
   
2. Stock.h
   
3. 
   
4. #ifndef STOCK_H_
   
5. #define STOCK_H_
   
6. 
   
7. #include <string>
   
8. #include <iostream>
   
9. 
   
10. using namespace std;
    
11. 
    
12. class Stock {
    
13. 
    
14. private:
    
15.     string m_name;
    
16.     double m_price;
    
17. 
    
18. public:
    
19.     Stock::Stock();
    
20.     Stock::Stock(double price = 0.0);
    
21.     Stock::Stock(string name = "defalut name", double price = 0.0);
    
22.     virtual ~Stock();
    
23. };
    
24. 
    
25. #endif /* STOCK_H_ */
    

复制代码

main调用的如果是

1. 
   
2. Stock myStock=2;
   
3. myStock=Stock("a",1.0);
   
4. myStock=Stock("abcde",3.0);
   

复制代码

则打印:
with param constractor
with param constractor
destory stock name:a ByeBye!
with param constractor
destory stock name:abcde ByeBye!
destory stock name:abcde ByeBye!

析构函数调用三次!
myStock = 2; 创建后，然后这个对象后来被销毁了，
因为myStock=Stock("a",1.0);
那为什么没有调用2这个对象的析构函数呢?


main调用的如果是

1. 
   
2. Stock myStock=Stock("a",1.0);
   
3. myStock=2;
   
4. myStock=Stock("abcde",3.0);
   

复制代码

则打印:
with param constractor
destory stock name:a ByeBye!
with param constractor
destory stock name:defautl name ByeBye!
with param constractor
destory stock name:abcde ByeBye!
destory stock name:abcde ByeBye!

析构函数调用四次!这个2对象被销毁了。


那为什么第一个不销毁那个2对象呢？

bruceteen

代码太长了吧
粗看了一下，没有输出拷贝构造函数吧

ppm10103

bruceteen 发表于 2013-05-07 15:31
代码太长了吧
粗看了一下，没有输出拷贝构造函数吧

就是个构造函数哦，代码很短的，就打印一下构造函数调用，打印了一下析构函数调用

bruceteen

回复 3# ppm10103

        Stock myStock=2; --- 构造myStock
        myStock=Stock("a",1.0); --- 构造 Stock("a",1.0)，并赋值到myStock，然后析构 Stock("a",1.0)
        myStock=Stock("abcde",3.0); --- 构造 Stock("abcde",3.0)，并赋值到myStock，然后析构 Stock("abcde",3.0)
                                                   --- 析构 myStock
结果一点儿也不奇怪呀！

而关于你的代码，无用的代码一大堆也就算了，还分成两个文件，纯粹增加别人的工作量。若是我，我会这些写：

1. #include <iostream>
   
2. using namespace std;
   
3. 
   
4. struct foo
   
5. {
   
6.     foo() {
   
7.         clog << "defautl constructor\n";
   
8.     }
   
9.     foo( const foo& ) {
   
10.         clog << "copy constructor\n";
    
11.     }
    
12.     foo& operator=( const foo& ) {
    
13.         clog << "operator=\n";
    
14.         return *this;
    
15.     }
    
16.     ~foo() {
    
17.         clog << "destructor\n";
    
18.     }
    
19. };
    
20. 
    
21. int main()
    
22. {
    
23.     {
    
24.         foo a;
    
25.         clog << "--------------------\n";
    
26.         a = foo();
    
27.         clog << "--------------------\n";
    
28.         a = foo();
    
29.         clog << "--------------------\n";
    
30.     }
    
31. 
    
32.     return 0;
    
33. }

复制代码

ppm10103

bruceteen 发表于 2013-05-07 15:55
回复 3# ppm10103

        Stock myStock=2; --- 构造myStock

那2这个对象不析构了？

bruceteen

回复 5# ppm10103
看你的主帖，最后一个 destory stock name:abcde ByeBye! 就是

ppm10103

bruceteen 发表于 2013-05-07 16:13
回复 5# ppm10103
看你的主帖，最后一个 destory stock name:abcde ByeBye! 就是

这个明显不是的哦，2对象没有name

ppm10103

1. 
   
2. 第一种情况的ASM
   
3. 
   
4. Stock myStock=2;
   
5. 00E01800  sub         esp,8  
   
6. 00E01803  fld         qword ptr [__real@4000000000000000 (0E0A860h)]  
   
7. 00E01809  fstp        qword ptr [esp]  
   
8. 00E0180C  lea         ecx,[ebp-44h]  
   
9. 00E0180F  call        Stock::Stock (0E0137Fh)  
   
10. 00E01814  mov         dword ptr [ebp-4],0  
    
11. myStock=Stock("a",1.0);
    
12. 00E0181B  sub         esp,8  
    
13. 00E0181E  fld1  
    
14. 00E01820  fstp        qword ptr [esp]  
    
15. 00E01823  sub         esp,20h  
    
16. 00E01826  mov         ecx,esp  
    
17. 00E01828  mov         dword ptr [ebp-128h],esp  
    
18. 00E0182E  push        offset string "a" (0E0A84Ch)  
    
19. 00E01833  call        std::basic_string<char,std::char_traits<char>,std::allocator<char> >::basic_string<char,std::char_traits<char>,std::allocator<char> > (0E0134Dh)  
    
20. 00E01838  mov         dword ptr [ebp-1A0h],eax  
    
21. 00E0183E  lea         ecx,[ebp-198h]  
    
22. 00E01844  call        Stock::Stock (0E01262h)  
    
23. 00E01849  mov         dword ptr [ebp-1A4h],eax  
    
24. 00E0184F  mov         eax,dword ptr [ebp-1A4h]  
    
25. 00E01855  mov         dword ptr [ebp-1A8h],eax  
    
26. 00E0185B  mov         byte ptr [ebp-4],1  
    
27. 00E0185F  mov         ecx,dword ptr [ebp-1A8h]  
    
28. 00E01865  push        ecx  
    
29. 00E01866  lea         ecx,[ebp-44h]  
    
30. 00E01869  call        Stock::operator= (0E010B4h)  
    
31. 00E0186E  mov         byte ptr [ebp-4],0  
    
32. 00E01872  lea         ecx,[ebp-198h]  
    
33. 00E01878  call        Stock::~Stock (0E01046h)  
    
34. myStock=Stock("abcde",3.0);
    
35. 00E0187D  sub         esp,8  
    
36. 00E01880  fld         qword ptr [__real@4008000000000000 (0E0A840h)]  
    
37. 00E01886  fstp        qword ptr [esp]  
    
38. 00E01889  sub         esp,20h  
    
39. 00E0188C  mov         ecx,esp  
    
40. 00E0188E  mov         dword ptr [ebp-11Ch],esp  
    
41. 00E01894  push        offset string "abcde" (0E0A838h)  
    
42. 00E01899  call        std::basic_string<char,std::char_traits<char>,std::allocator<char> >::basic_string<char,std::char_traits<char>,std::allocator<char> > (0E0134Dh)  
    
43. 00E0189E  mov         dword ptr [ebp-1A0h],eax  
    
44. 00E018A4  lea         ecx,[ebp-160h]  
    
45. 00E018AA  call        Stock::Stock (0E01262h)  
    
46. 00E018AF  mov         dword ptr [ebp-1A4h],eax  
    
47. 00E018B5  mov         eax,dword ptr [ebp-1A4h]  
    
48. 00E018BB  mov         dword ptr [ebp-1A8h],eax  
    
49. 00E018C1  mov         byte ptr [ebp-4],2  
    
50. 00E018C5  mov         ecx,dword ptr [ebp-1A8h]  
    
51. 00E018CB  push        ecx  
    
52. 00E018CC  lea         ecx,[ebp-44h]  
    
53. 00E018CF  call        Stock::operator= (0E010B4h)  
    
54. 00E018D4  mov         byte ptr [ebp-4],0  
    
55. 00E018D8  lea         ecx,[ebp-160h]  
    
56. 00E018DE  call        Stock::~Stock (0E01046h)  
    
57. system("pause");
    
58. 00E018E3  mov         esi,esp  
    
59. 00E018E5  push        offset string "pause" (0E0A830h)  
    
60. 00E018EA  call        dword ptr [__imp__system (0E0E450h)]  
    
61. 00E018F0  add         esp,4  
    
62. 00E018F3  cmp         esi,esp  
    
63. 00E018F5  call        @ILT+700(__RTC_CheckEsp) (0E012C1h)  
    
64. return 0;
    
65. 
    
66. 第二种情况的ASM
    
67. Stock myStock=Stock("a",1.0);
    
68. 00B81810  sub         esp,8  
    
69. 00B81813  fld1  
    
70. 00B81815  fstp        qword ptr [esp]  
    
71. 00B81818  sub         esp,20h  
    
72. 00B8181B  mov         ecx,esp  
    
73. 00B8181D  mov         dword ptr [ebp-128h],esp  
    
74. 00B81823  push        offset string "a" (0B8A85Ch)  
    
75. 00B81828  call        std::basic_string<char,std::char_traits<char>,std::allocator<char> >::basic_string<char,std::char_traits<char>,std::allocator<char> > (0B81357h)  
    
76. 00B8182D  mov         dword ptr [ebp-1D8h],eax  
    
77. 00B81833  lea         ecx,[ebp-1D0h]  
    
78. 00B81839  call        Stock::Stock (0B81262h)  
    
79. 00B8183E  mov         dword ptr [ebp-1DCh],eax  
    
80. 00B81844  mov         eax,dword ptr [ebp-1DCh]  
    
81. 00B8184A  mov         dword ptr [ebp-1E0h],eax  
    
82. 00B81850  mov         dword ptr [ebp-4],0  
    
83. 00B81857  mov         ecx,dword ptr [ebp-1E0h]  
    
84. 00B8185D  push        ecx  
    
85. 00B8185E  lea         ecx,[ebp-44h]  
    
86. 00B81861  call        Stock::Stock (0B81307h)  
    
87. 00B81866  mov         byte ptr [ebp-4],2  
    
88. 00B8186A  lea         ecx,[ebp-1D0h]  
    
89. 00B81870  call        Stock::~Stock (0B81046h)  
    
90. myStock=2;
    
91. 00B81875  sub         esp,8  
    
92. 00B81878  fld         qword ptr [__real@4000000000000000 (0B8A850h)]  
    
93. 00B8187E  fstp        qword ptr [esp]  
    
94. 00B81881  lea         ecx,[ebp-198h]  
    
95. 00B81887  call        Stock::Stock (0B81389h)  
    
96. 00B8188C  mov         byte ptr [ebp-4],3  
    
97. 00B81890  lea         eax,[ebp-198h]  
    
98. 00B81896  push        eax  
    
99. 00B81897  lea         ecx,[ebp-44h]  
    
100. 00B8189A  call        Stock::operator= (0B810B4h)  
     
101. 00B8189F  mov         byte ptr [ebp-4],2  
     
102. 00B818A3  lea         ecx,[ebp-198h]  
     
103. 00B818A9  call        Stock::~Stock (0B81046h)  
     
104. myStock=Stock("abcde",3.0);
     
105. 00B818AE  sub         esp,8  
     
106. 00B818B1  fld         qword ptr [__real@4008000000000000 (0B8A840h)]  
     
107. 00B818B7  fstp        qword ptr [esp]  
     
108. 00B818BA  sub         esp,20h  
     
109. 00B818BD  mov         ecx,esp  
     
110. 00B818BF  mov         dword ptr [ebp-11Ch],esp  
     
111. 00B818C5  push        offset string "abcde" (0B8A838h)  
     
112. 00B818CA  call        std::basic_string<char,std::char_traits<char>,std::allocator<char> >::basic_string<char,std::char_traits<char>,std::allocator<char> > (0B81357h)  
     
113. 00B818CF  mov         dword ptr [ebp-1D8h],eax  
     
114. 00B818D5  lea         ecx,[ebp-160h]  
     
115. 00B818DB  call        Stock::Stock (0B81262h)  
     
116. 00B818E0  mov         dword ptr [ebp-1DCh],eax  
     
117. 00B818E6  mov         eax,dword ptr [ebp-1DCh]  
     
118. 00B818EC  mov         dword ptr [ebp-1E0h],eax  
     
119. 00B818F2  mov         byte ptr [ebp-4],4  
     
120. 00B818F6  mov         ecx,dword ptr [ebp-1E0h]  
     
121. 00B818FC  push        ecx  
     
122. 00B818FD  lea         ecx,[ebp-44h]  
     
123. 00B81900  call        Stock::operator= (0B810B4h)  
     
124. 00B81905  mov         byte ptr [ebp-4],2  
     
125. 00B81909  lea         ecx,[ebp-160h]  
     
126. 00B8190F  call        Stock::~Stock (0B81046h)  
     
127. system("pause");
     
128. 00B81914  mov         esi,esp  
     
129. 00B81916  push        offset string "pause" (0B8A830h)  
     
130. 00B8191B  call        dword ptr [__imp__system (0B8E450h)]  
     
131. 00B81921  add         esp,4  
     
132. 00B81924  cmp         esi,esp  
     
133. 00B81926  call        @ILT+700(__RTC_CheckEsp) (0B812C1h)  
     
134. return 0;
     

复制代码

ASM代码看出来，第一种情况的2的那个对象的析构函数没被调用，为什么呢？？

learningl

LZ，在你说结果的时候，应该附上你所使用的编译器。

我的分析如下
----------------------------------------------------------
main调用的如果是
1    Stock myStock=2;
2   myStock=Stock("a",1.0);
3   myStock=Stock("abcde",3.0);

with param constractor                     -> 由1产生，此处并未产生临时变量。
with param constractor                     -> 由2Stock("a",1.0)产生，由于这里Stock("a",1.0)，是一个临时变量，所以会有一个对应的析构
destory stock name:a ByeBye!          -> 2处对应的析构
with param constractor                     -> 同上面的道理，由3Stock("abcde",3.0)产生，同理是一个临时变量，所以会有一个析构
destory stock name:abcde ByeBye!  -> 3处对应的析构
destory stock name:abcde ByeBye!  -> 由1处产生，因为程序结束，所以myStock会调用析构，并且此时myStock中的m_name，已经被第3行的调用修改，所以也显示为abcde

----------------------------------------------------------
main调用的如果是
1    Stock myStock=Stock("a",1.0);
2    myStock=2;
3    myStock=Stock("abcde",3.0);

with param constractor
destory stock name:a ByeBye!
with param constractor
destory stock name:defautl name ByeBye!
with param constractor
destory stock name:abcde ByeBye!
destory stock name:abcde ByeBye!

析构函数调用四次!这个2对象被销毁了。
那为什么第一个不销毁那个2对象呢？

这个应该是错误的，构造的次数应该和析构的次数是成对的
我的结果如下 （g++ (GCC) 4.5.2）
with param constractor                                             
with param constractor
destory stock name:defautl name ByeBye!
with param constractor
destory stock name:abcde ByeBye!
destory stock name:abcde ByeBye!
原因同上面的分析。

井蛙夏虫

回复 9# learningl
LZ的结果是对的。第二个测试的myStock是调用拷贝构造函数创建的。