[已解决]构造函数和析构函数的调用

xieglt

解释在注释里头

1. #include<iostream>
   
2. using namespace std;
   
3. class Ctyre           //轮胎类
   
4. 
   
5. {
   
6. private:
   
7.     int radius;       //半径
   
8.     int width;         // 宽度
   
9.        
   
10. public:
    
11.     Ctyre() :radius(16), width(185)
    
12.     {
    
13.         cout << radius << "\tCtyre  构造函数" << endl;
    
14.                
    
15.     }
    
16.     Ctyre(int r, int w) :radius(r), width(w)
    
17.     {
    
18.         cout << radius << " \t Ctyre  构造函数 " << endl;
    
19.                
    
20.     }
    
21.        
    
22.     ~Ctyre()
    
23.     {
    
24.         cout << radius << "\tCtyre  析构函数" << endl;
    
25.                
    
26.     }
    
27.     int getRadius()
    
28.                
    
29.     {
    
30.         return radius;
    
31.                
    
32.     }
    
33.     int getWidth()
    
34.     {
    
35.         return width;
    
36.                
    
37.     }
    
38. };
    
39. 
    
40. class Ccar       //汽车类
    
41. 
    
42. {
    
43. private:
    
44.     int price; // 价格
    
45.        
    
46.     Ctyre tyre;
    
47.        
    
48. public:
    
49.     Ccar();
    
50.        
    
51.     Ccar(int p, int tr, int tw);
    
52.        
    
53.     ~Ccar();
    
54.     int getPrice()
    
55.     {
    
56.         return price;
    
57.     }
    
58.        
    
59.         //这里应该写成 Ctyre & getCtyre() 返回引用，即返回成员变量的地址
    
60.         //否则，编译器将在栈上构造一个临时的 Ctyre 对象
    
61.     Ctyre getCtyre()
    
62.     {
    
63.         return tyre;
    
64.     }
    
65.        
    
66.        
    
67. };
    
68. Ccar::Ccar()
    
69. {
    
70.         //这里调用 ctyre 会构造一个对象，另外还会构造一个成员变量 tyre 这里是构造 2 个
    
71.     price = 50010; Ctyre(); cout <<price << " \t Ccar 构造函数" << endl;
    
72. }
    
73. Ccar::Ccar(int p, int tr, int tw) : price(p), tyre(tr, tw)
    
74. {
    
75.     cout << price << " \tCcar 构造函数 " << endl;
    
76.        
    
77.        
    
78.        
    
79. }
    
80. 
    
81. Ccar::~Ccar()
    
82. {
    
83.         cout << price << "\tCcar  析构函数" << endl;
    
84. }
    
85. 
    
86. int main()
    
87. {
    
88.         //这里构造了一个 Ctyre 对象  +1
    
89.     Ccar car(48900, 17, 225);
    
90.        
    
91.     cout << " price =" << car.getPrice();
    
92.         //这里构造了 2个临时 Ctyre 对象 + 2 ,
    
93.         //这两个临时对象走的是 拷贝构造函数 或者 = 重载函数 ，你没有定义，编译器自己帮你定义了
    
94.         //Ctyre(const Ctyre &)
    
95.         //Ctyre & operator = (const Ctyre &)
    
96.     cout << "\t Ctyre .radius = " << car.getCtyre().getRadius()
    
97.         << " \tCtyre .width = " << car.getCtyre().getWidth() << endl;
    
98.        
    
99.         //这里构造了 2个 Ctyre 对象 +2
    
100.     Ccar car1;
     
101.     cout << " price =" << car1.getPrice();
     
102.         //这里构造了2个临时 Ctyre 对象 +2
     
103.         //这两个临时对象走的是 拷贝构造函数 或者 = 重载函数
     
104.     cout << "\t Ctyre .radius = " << car1.getCtyre().getRadius()
     
105.         << " \tCtyre .width = " << car1.getCtyre().getWidth() << endl;
     
106.        
     
107.         //总共是 7 个 Ctyre 对象,你数一数析构输出看对不对
     
108.         return 0;
     
109. }

复制代码