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

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对象呢？

lost_templar

constructor -- copy constructor -- move constructor
copy assignment -- move assignment

井蛙夏虫

回复 14# ppm10103
你没有重载以int为参数的operator=函数，c++中只有一个参数的类成员函数也可以用来做隐式类型转换(带explicit关键字除外),
所以myStock=2实际的流程应当类似这样: 2 --> double(int) --> Stock(double) --> operator=(const Stock&);
如果你将Stock(double)构造函数带上explicit,你的程序将变异失败。
   

littledick

拷贝构造和赋值操作都没搞清楚么{:3_185:}
还滥用默认参数。

ppm10103

回复 9# learningl


是VC++2010

Stock myStock = Stock("a", 1.0);
myStock = 2;

with param constractor
destory stock name:a ByeBye! 临时1.0对象析构
with param constractor
destory stock name:defautl name ByeBye! 临时2对象析构
destory stock name:defautl name ByeBye! myStock对象析构


那这个myStock = 2应该也不会生成临时变量才对啊

   

ppm10103

多谢各位了，拷贝构造的

ppm10103

井蛙夏虫 发表于 2013-05-07 20:23
2对象的name被myStock=Stock("a",1.0)改为a了，又被myStock=Stock("abcde",3.0)改为abcde。
它的析构对应最 ...

一个是三次构造函数调用，四次析构函数调用

一个是三次构造函数调用，三次析构函数调用

井蛙夏虫

2对象的name被myStock=Stock("a",1.0)改为a了，又被myStock=Stock("abcde",3.0)改为abcde。
它的析构对应最后一句destory stock name:abcde ByeBye!。

不过LZ的函数重载有问题。当这样定义(Stock myStock时，三个构造函数都匹配。

井蛙夏虫

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



   

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!
原因同上面的分析。