创建数据结构库基础设施——异常类的构建

1，数据结构库架构图（本文暂时架构图，后有更改）：

 

2，依赖异常类创建的库稳定性很好；

3，异常类型可以是自定义类类型：

       1，对于类类型异常的匹配依旧是至上而下严格匹配；

       2，赋值兼容性原则在异常匹配中依然适用；

       3，一般而言：

              1，匹配子类异常的 catch 放在上部；

              2，匹配父类异常的 catch 放在下部；

             

4，纯虚的析构函数仅仅用来说明当前的类是抽象类，其它没有任何说明了；

5，纯虚析构函数的实现：

       1，C++ 中规定纯虚函数不需要提供实现，等着子类实现；

       2，C++ 中规定，只要定义了析构函数，不管其是否为纯虚函数，一定要提供实现，因为在实现一个析构函数的时候，最后肯定要调用父类的析构函数，如果父类的析构函数是纯虚函数，并且这个纯虚函数没有具体实现，则调用到顶层父类的析构函数时没有实现，则更加奇怪，所以 C++ 语言规定了这个原则；

6，现代 C++ 库必然包含必要的异常类族，异常类是数据结构类所依赖的“基础设施”，其成员关系为：

 

 

7，异常类功能定义：

 

 

8，异常类中的接口定义：

 

 

9，异常类族创建：

1，Exception.h 的创建：

#ifndef EXCEPTION_H
#define EXCEPTION_H

#include "Object.h"

namespace DTLib
{

#define THROW_EXCEPTION(e, m) (throw e(m, __FILE__, __LINE__))  //直接抛出异常对象，具体文件名和行号宏自己写出；当不能够用异常处理机制的时候，只需用在这里注释掉就可以了

class Exception : public Object   // 设计为顶层的抽象类，没有对象，只能继承；
{
protected:
    char* m_message;
    char* m_location;
void init(const char* message, const char* file, int line);

public:
    Exception(const char* message);
    Exception(const char* file, int line);
    Exception(const char* message, const char* file, int line);
    Exception(const Exception& e);
Exception& operator= (const Exception& e);

    virtual const char* message() const;    // 详细的异常说明信息；
    virtual const char* location() const;   // 定位异常位置信息；
    virtual ~Exception() = 0;   //抽象类，析构函数用虚函数；纯虚函数的实现等着子类来完成；但凡定义析构函数，必须实现，因为析构函数时，必须要调用父类的析构函数。
};

class ArithmeticException : public Exception
{
public:
    ArithmeticException() : Exception(0){}
    ArithmeticException(const char* message) : Exception(message){}
    ArithmeticException(const char *file, int line) : Exception(file, line){}
    ArithmeticException(const char* message, const char* file, int line) : Exception(message, file, line){}
    ArithmeticException(const ArithmeticException& e) : Exception(e) {}
    ArithmeticException& operator =(const ArithmeticException& e)
    {
        Exception::operator =(e);

        return *this;
    }
};

class NullPointerException : public Exception
{
public:
    NullPointerException() : Exception(0){}
    NullPointerException(const char* message) : Exception(message){}
    NullPointerException(const char *file, int line) : Exception(file, line){}
    NullPointerException(const char* message, const char* file, int line) : Exception(message, file, line){}
    NullPointerException(const NullPointerException& e) : Exception(e) {}
    NullPointerException& operator =(const NullPointerException& e)
    {
        Exception::operator =(e);

        return *this;
    }
};

class IndexOutOfBoundsException : public Exception
{
public:
    IndexOutOfBoundsException() : Exception(0){}
    IndexOutOfBoundsException(const char* message) : Exception(message){}
    IndexOutOfBoundsException(const char *file, int line) : Exception(file, line){}
    IndexOutOfBoundsException(const char* message, const char* file, int line) : Exception(message, file, line){}
    IndexOutOfBoundsException(const IndexOutOfBoundsException& e) : Exception(e) {}
    IndexOutOfBoundsException& operator =(const IndexOutOfBoundsException& e)
    {
        Exception::operator =(e);

        return *this;
    }
};

class NoEnoughMemoryException : public Exception
{
public:
    NoEnoughMemoryException() : Exception(0){}
    NoEnoughMemoryException(const char* message) : Exception(message){}
    NoEnoughMemoryException(const char *file, int line) : Exception(file, line){}
    NoEnoughMemoryException(const char* message, const char* file, int line) : Exception(message, file, line){}
    NoEnoughMemoryException(const NoEnoughMemoryException& e) : Exception(e) {}
    NoEnoughMemoryException& operator =(const NoEnoughMemoryException& e)
    {
        Exception::operator =(e);

        return *this;
    }
};

class InvalidParameterException : public Exception
{
public:
    InvalidParameterException() : Exception(0){}
    InvalidParameterException(const char* message) : Exception(message){}
    InvalidParameterException(const char *file, int line) : Exception(file, line){}
    InvalidParameterException(const char* message, const char* file, int line) : Exception(message, file, line){}
    InvalidParameterException(const InvalidParameterException& e) : Exception(e) {}
    InvalidParameterException& operator =(const InvalidParameterException& e)
    {
        Exception::operator =(e);

        return *this;
    }
};

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;
    }
};

}

#endif // EXCEPTION_H

2，Exception.cpp的创建：

#include "Exception.h"
#include <cstring>
#include <cstdlib>

using namespace std;

namespace DTLib
{

void Exception::init(const char* message, const char* file, int line)
{
　　 m_message = (message ? strdup(message) : NULL);  // 将message复制一份指向堆空间，而内容相同;保证是独立的堆空间；采用三目运算符因为 message 可能为空但是 strdup 没有判断为空的情况；

    if( file != NULL)
    {
        char sl[16] = {0};

        itoa(line, sl, 10);     //这里不懂

        m_location = static_cast<char*>(malloc(strlen(file) + strlen(sl) + 2));  // 加上冒号和结束符；

        if( m_location != NULL )  // 对于 DTLib 里面的类的话，动态申请后一定要判断是否为空指针，这里不再做为空的异常处理，免得陷入死循环
        {
            m_location = strcpy(m_location, file);
            m_location = strcat(m_location, ":");
            m_location = strcat(m_location, sl);
        }
    }
    else
    {
        m_location = NULL;  // 这里已经做了 m_location 为空的准备；
    }
}

Exception::Exception(const char* message)
{
    init(message, NULL, 0);
}

Exception::Exception(const char* file, int line)
{
    init(NULL, file, line);
}

Exception::Exception(const char* message, const char* file, int line)
{
    init(message, file, line);
}

Exception::Exception(const Exception& e)  //深拷贝，必须实现
{
    m_message = strdup(e.m_message);    // 保证是独立的堆空间；
    m_location = strdup(e.m_location);
}

Exception& Exception::operator= (const Exception& e)//深拷贝，必须实现
{
    if( this != &e)
    {
        free(m_message);
        free(m_location);

        m_message = strdup(e.m_message);    // 保证是独立的堆空间；
        m_location = strdup(e.m_location);
}

    return *this;
}

const char* Exception::message() const
{
    return m_message;
}

const char* Exception::location() const
{
    return m_location;
}

Exception::~Exception()
{
    free(m_message);
    free(m_location);
}

10，设计原则：

       1，在可复用代码库设计时，尽量使用面相对象技术进行架构；

       2，尽量使用异常处理机制分离正常逻辑和异常逻辑；

11，小结：

　　1，现代 C++ 库必然包含必要的异常类族；

　　2，所有库中的数据结构都依赖于异常机制；

　　3，异常机制能够分离库中代码的正常逻辑和异常逻辑；