第4课 - 顶层父类的创建

在开始创建顶层父类之前，先补充两点知识，主要是为了解释为什么需要顶层父类，以及顶层父类在DTLib中的作用。

 

1. 软件架构实践经验

在面向对象软件架构实践中，总结出了以下三条经验：

 - 尽量使用单重继承的方式进行系统设计

 - 尽量保持系统中只存在单一的继承树

 - 尽量使用组合关系代替继承关系

但不幸的是：

 - C++语言的灵活性使得代码中可以存在多个继承树

 - C++编译器的差异使得同样的代码可能表现不同的行为，举个例子，new操作如果失败会发生什么？

2. new操作失败会发生什么

【常见的动态内存分配代码】

/*C代码*/
int *p = (int *)malloc(10 * sizeof(int));

if (p != NULL)
{
    //......
}

/*C++代码*/
int *p = new int(10);

if (p != NULL)
{
    //......
}

【必须知道的事实】

 - malloc函数申请失败时返回NULL

 - new申请失败时，根据编译器的不同，其结果可能为：

     1.返回NULL（早期C++编译器）

     2.抛出std::bad_alloc异常（现代C++编译器大多采取这种结方式）

【如何跨编译器统一new的行为，提高代码移植性】

 可以考虑的解决方案有：

 - 类层次范围：重载new/delete，不抛出任何异常。

 - 单次动态内存分配：使用nothrow参数，指明不抛出异常。

3. 顶层父类Object设计

【创建Object类的意义】

 - 遵循经典设计准则，DTLib中所有数据结构类都继承自Object，保证单一继承树

 - 在Object类中重载new/delete，统一动态内存申请的行为，提高代码移植性

【接口定义】

#ifndef OBJECT_H
#define OBJECT_H

namespace DTLib
{

class Object
{
public:
    void *operator new(unsigned int size) throw();
    void operator delete(void *p);
    void *operator new[](unsigned int size) throw();
    void operator delete[](void *p);
    virtual ~Object() = 0;
};

}

#endif // OBJECT_H

【接口实现】

考虑到malloc()申请内存失败是固定返回NULL值，因此new和new[]的重载实现为调用malloc()，delete和delete[]的重载实现为调用free()。

#include "Object.h"
#include <cstdlib>

namespace DTLib
{

void *Object::operator new(unsigned int size) throw()
{
    return malloc(size);
}

void Object::operator delete(void *p)
{
    free(p);
}

void *Object::operator new[](unsigned int size) throw()
{
    return malloc(size);
}

void Object::operator delete[](void *p)
{
    free(p);
}

Object::~Object()
{

}

}

需要注意的是，重载的new、delete仅在同时满足以下条件时适用：
1.使用了DTLib命名空间 using namespace DTLib; 
2.动态申请Object的子类对象 Test *obj = new Test(); //class Test : public Object 

【测试示例】

先在new/delete、new[]/delete[]的重载函数中添加一行测试代码：

void *Object::operator new(unsigned int size) throw()
{
    cout << "Object::operator new: " << size << endl;
    return malloc(size);
}

void Object::operator delete(void *p)
{
    cout << "Object::operator delete: " << p << endl;
    free(p);
}

void *Object::operator new[](unsigned int size) throw()
{
    cout << "Object::operator new[]: " << size << endl;
    return malloc(size);
}

void Object::operator delete[](void *p)
{
    cout << "Object::operator delete[]: " << p << endl;
    free(p);
}

然后编写main.cpp测试代码：

#include "Object.h"
#include <iostream>

using namespace DTLib;
using namespace std;

class Test1 : public Object
{
public:
    int i;
    int j;
};

class Test2 : public Test1
{
public:
    int k;
};

int main()
{ 
    Test1 *obj1 = new Test1;
    Test2 *obj2 = new Test2;

    cout << "obj1 = " << obj1 << endl;
    cout << "obj2 = " << obj2 << endl;

    delete obj1;
    delete obj2;

    cout << endl;

    Test1 *obj3 = new Test1[10];
    Test2 *obj4 = new Test2[10];

    cout << "obj3 = " << obj3 << endl;
    cout << "obj4 = " << obj4 << endl;

    delete[] obj3;
    delete[] obj4;

    return 0;
}

运行结果：

PS：测试结果显示obj3和obj4的size分别为124和164，都比理论值多了4字节，这里引用https://blog.csdn.net/hazir/article/details/21413833一文中的部分内容进行解释。

 

如何申请和释放一个数组？

我们经常要用到动态分配一个数组，也许是这样的：

string *psa = new string[10];      //array of 10 empty strings
int *pia = new int[10];           //array of 10 uninitialized ints

上面在申请一个数组时都用到了 new [] 这个表达式来完成，按照我们上面讲到的 new 和 delete 知识，第一个数组是 string 类型，分配了保存对象的内存空间之后，将调用 string 类型的默认构造函数依次初始化数组中每个元素；第二个是申请具有内置类型的数组，分配了存储 10 个 int 对象的内存空间，但并没有初始化。

如果我们想释放空间了，可以用下面两条语句：

delete [] psa;
delete [] pia;

都用到 delete [] 表达式，注意这地方的 [] 一般情况下不能漏掉！我们也可以想象这两个语句分别干了什么：第一个对 10 个 string 对象分别调用析构函数，然后再释放掉为对象分配的所有内存空间；第二个因为是内置类型不存在析构函数，直接释放为 10 个 int 型分配的所有内存空间。

这里对于第一种情况就有一个问题了：我们如何知道 psa 指向对象的数组的大小？怎么知道调用几次析构函数？

这个问题直接导致我们需要在 new [] 一个对象数组时，需要保存数组的维度，C++ 的做法是在分配数组空间时多分配了 4 个字节的大小，专门保存数组的大小，在 delete [] 时就可以取出这个保存的数，就知道了需要调用析构函数多少次了。

还是用图来说明比较清楚，我们定义了一个类 A，但不具体描述类的内容，这个类中有显示的构造函数、析构函数等。那么 当我们调用

class A *pAa = new A[3];

时需要做的事情如下：

从这个图中我们可以看到申请时在数组对象的上面还多分配了 4 个字节用来保存数组的大小，但是最终返回的是对象数组的指针，而不是所有分配空间的起始地址。

这样的话，释放就很简单了：

delete [] pAa;

这里要注意的两点是：

• 调用析构函数的次数是从数组对象指针前面的 4 个字节中取出；
• 传入 operator delete[] 函数的参数不是数组对象的指针 pAa，而是 pAa 的值减 4。

4. 异常类改进

 根据所设计的顶层父类Object，对上次创建的异常类进行如下改进：

 【改进点一】

Exception类继承自Object类 class Exception : public Object ，使得在堆空间创建异常类对象失败时，返回NULL指针。

【改进点二】

新增InvalidOperationException非法操作异常类，当类的成员函数被调用时，如果状态不正确(如一些成员函数在类对象刚初始化时不允许使用)则抛出异常

/*
 * 非法操作异常：类的成员函数被调用时，如果状态不正确(如一些成员函数在类对象刚初始化时不允许使用)则抛出异常
*/
class InvalidOperationException : public Exception
{
public:
    InvalidOperationException() : Exception(0) { }
    InvalidOperationException(const char *message) : Exception(message) { }
    InvalidOperationException(const char *file, int line) : Exception(file, line) { }
    InvalidOperationException(const char *message, const char *file, int line) : Exception(message, file, line) { }

    InvalidOperationException(const InvalidOperationException& e) : Exception(e) { }
    InvalidOperationException &operator = (const InvalidOperationException &e)
    {
        Exception::operator =(e);
        return *this;
    }
};

5. DTLib的开发方式和注意事项

1. 迭代开发：每次完成一个小的目标，持续开发，最终打造可复用类库
2. 单继承，单一继承树：所有类都继承自Object，统一规范堆对象创建时的行为
3. 只抛异常，不处理异常：使用THROW_EXCEPTION抛异常，提高可移植性
4. 弱耦合性：尽量不使用std标准库中的类和函数，提高可移植性

 

注：本文整理于狄泰《数据结构开发实战教程》课程内容