顶层父类

1. 当代软件架构实践中的经验

（1）尽量使用单重继承的方式进行系统设计（尽量不要一个类继承多个父类）

（2）尽量保持系统中只存在单一的继承树（创建一个顶层得抽象父类）

（3）尽量使用组合关系代替继承关系

2. 不幸的事实

（1）C++语言的灵活性使得代码中可以存在多个继承树（多个继承树会使得代码质量的就下降）

（2）C++编译器的差异使得同样的代码不同的编译器可能表现不同的行为（如new操作结果失败，有的编译器会返回NULL，有的会抛std::bad_alloc异常）

3. 创建DTLib::Object类的意义

（1）遵循经典设计准则，所有数据结构都继承自Object类

（2）定义动态内存申请的行为，提高代码的移植性（即重载operator new，让new的失败时在不同的编译器下都能返回NULL，而不是抛出异常或返回NULL等多种结果）

顶层父类接口定义

 1 class Object
 2 {
 3 public:
 4     //以下四个重载函数用于统一不同编译器new失败时的结果不同的问题。
 5     //throw()表示不抛出异常，即如果申请内请失败时，统一返回NULL而不抛异常
 6     void* operator new(unsigned int size) throw();
 7     void operator delete(void* p);
 8     void* operator new[](unsigned int size) throw();
 9     void operator delete[](void* p);
10 
11     virtual ~Object() = 0;
12 };

示例代码如下：

object.h

 1 #ifndef OBJECT_H
 2 #define OBJECT_H
 3 
 4 
 5 namespace DTLib
 6 {
 7 
 8     class Object
 9     {
10     public:
11         //以下四个重载函数用于统一不同编译器new失败时的结果不同的问题。
12         //throw()表示不抛出异常，即如果申请内请失败时，统一返回NULL而不抛异常
13         void* operator new(unsigned int size) throw();
14         void operator delete(void* p);
15 
16         void* operator new[](unsigned int size) throw();
17         void operator delete[](void* p);
18 
19         virtual  ~Object()=0;
20     };
21 }
22 #endif // OBJECT_H

object.cp

 1 #include "object.h"
 2 #include "cstdlib"
 3 #include<iostream>
 4 
 5 using namespace std;
 6 namespace DTLib
 7 {
 8 
 9 void* Object::operator new(unsigned int size) throw()
10 {
11     cout<<"Object::operator new : "<< size<<endl;
12     return malloc(size);//这里的size代表申请内存空间的字节数
13 }
14 
15 void Object::operator delete(void* p) 
16 {
17     cout<<"Object::operator delete : "<<p<<endl;
18     
19     free(p);
20 }
21 
22 void* Object::operator new[](unsigned int size) throw()
23 {
24     cout<<"Object::operator new[]"<<endl;
25 
26     return  malloc(size);//此时的size代表申请对象的数量
27 }
28 
29 void Object::operator delete[](void* p)
30 {
31     cout<<"Object::operator delete[]:"<<p<<endl;
32     
33     free(p);
34 }
35 
36 Object::~Object()
37 {
38 
39 }
40 }

测试代码：

 1 #include<iostream>
 2 #include "object.h"
 3 
 4 using namespace std;
 5 using namespace DTLib;
 6 
 7 class Test:public Object
 8 {
 9     int i;
10     int j;
11 public:
12     Test()
13     {
14         cout<<"Test()"<<endl;
15     }
16     ~Test()
17     {
18         cout<<"~Test()"<<endl;
19     }
20 };
21 
22 class Child:public Test
23 {
24     int t;
25 public:
26     Child()
27     {
28         cout<<"Child()"<<endl;
29     }
30     ~Child()
31     {
32         cout<<"~Child()"<<endl;
33     }
34 };
35 
36 int main(int argc, char const *argv[])
37 {
38     Object* object1=new Test();
39     Object* object2=new Child();
40 
41     cout<<"object1 ="<<object1<<endl;
42     cout<<"object2 ="<<object2<<endl;
43 
44     delete object1;
45     delete object2;
46 
47     system("pause");
48     
49     return 0;
50 }

小结

（1）Object类是DTLib中数据结构类的顶层父类

（2）Object类用于统一动态内存申请的行为

（3）在堆中创建Object子类的对象，失败时返回NULL值。

（4）Object类为纯虚父类，所有子类都能进行动态类型识别。