[C++, Basic, 02] 控制对象初始化与析构的顺序

ObjDef.h

 1 /*
 2  *
 3  * Date: 2019.09.07
 4  *
 5  */
 6 
 7 #ifndef _H_H_OBJ_DEF_H_H_
 8 #define _H_H_OBJ_DEF_H_H_
 9 
10 #include 
11 
12 class ObjA
13 {
14 public:
15     ObjA() { std::cout << "Construct ObjA" << std::endl; }
16     ~ObjA() { std::cout << "Destruct ObjA" << std::endl;  }
17 };
18 
19 class ObjB
20 {
21 public:
22     ObjB() { std::cout << "Construct ObjB" << std::endl; }
23     ~ObjB() { std::cout << "Destruct ObjB" << std::endl; }
24 };
25 
26 class ObjC
27 {
28 public:
29     ObjC() { std::cout << "Construct ObjC" << std::endl; }
30     ~ObjC() { std::cout << "Destruct ObjC" << std::endl; }
31 };
32 
33 #endif

问题描述：

假如有多个对象，如何控制每个对象的初始化与析构？

方法1：

使用指针。

如下代码：

 1 /*
 2  *
 3  * Date: 2019.09.07
 4  *
 5  */
 6 
 7 #include 
 8 
 9 #include "ObjDef.h"
10 
11 int main()
12 {
13     ObjA* pAObj = NULL;
14     ObjB* pBObj = NULL;
15     ObjC* pCObj = NULL;
16 
17     // Frist initialize ObjB object.
18     pBObj = new ObjB();
19 
20     // Next ObjC
21     pCObj = new ObjC();
22 
23     // Next ObjA
24     pAObj = new ObjA();
25     
26     std::cout << "Hello World" << std::endl;
27 
28     // Frist free ObjC
29     delete pCObj;
30 
31     // Next ObjA
32     delete pAObj;
33 
34     // Next ObjB
35     delete pBObj;
36 
37 
38     return 0;
39 }

执行结果：

 

 总结：

关键字new在使用的时候，分配对象内存，调用对象构造函数。

关键字delete在使用的时候，调用对象析构函数，释放对象占用内存。

方法2：

使用局部静态对象。如下代码所示。

 1 #include 
 2 
 3 #include "ObjDef.h"
 4 
 5 ObjA& theObjA()
 6 {
 7     static ObjA a;
 8     return a;
 9 }
10 
11 ObjB& theObjB()
12 {
13     static ObjB b;
14     return b;
15 }
16 
17 ObjC& theObjC()
18 {
19     static ObjC c;
20     return c;
21 }
22 
23 
24 int main()
25 {
26     // Frist ObjA
27     ObjA &a = theObjA();
28 
29     // Next ObjC
30     ObjC& c = theObjC();
31 
32     // Next ObjB
33     ObjB& b = theObjB();
34 
35     std::cout << "Hello World" << std::endl;
36 }

执行结果：

 

 总结分析：

 使用局部静态化对象，在调用相关函数时，完成对象的初始化，在main函数执行完毕，会按相反顺序进行释放。