第十三课 类族结构的进化

　　前几节我们开发的智能指针类和异常类族并没有继承自Object，现在我们需要将它们进行整合，作为DTLib这个类库的基础设施。整合的时候需要遵循现代软件的架构模式。

　　遵循经典设计准则

　　　　DTLib中所有类位于单一继承树，可以根据下图中的方式进行整合：

　　在异常类族中有了新的成员InvalidOperationException异常类。为什么要增加这个异常类呢？因为我们创建的数据结构类是有状态的，在不同状态下，成员函数调用的行为是不同的。特别的在某些类对象的初识状态下，某些成员函数是不能调用的，如果硬是要调用这些函数，就会抛出这个非法操作的异常。

改进的关键点：

　　Exception类继承自Object类

　　　　堆空间中创建异常对象失败时，返回NULL指针

　　新增InvalidOperationException异常类

　　　　成员函数调用时，如果状态不正确则抛出异常

　　SmartPointer类继承自Object类

　　　　堆空间中创建智能指针对象失败时，返回NULL指针

DTLib中类的使用原则：

　　如果在堆空间中创建DTLib库中的对象，创建完之后要判断一下是否返回了一个合法的指针。因为创建失败时是不会返回异常的。

 改造后的程序库如下：

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, 0, 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, 0, 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, 0, 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, 0, 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, 0, 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, 0, 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

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 = strdup(message);

    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)
        {
            m_location = strcpy(m_location, file);
            m_location = strcat(m_location, ":");
            m_location = strcat(m_location, sl);
        }
    }
    else
    {
        m_location = NULL;
    }
}

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_message = 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);
}

}

第22行的init函数中我们加入了空指针的判断，当malloc申请不成功时，也即m_location为空时，我们什么也不做，就让m_location为空。如果m_location为空，我们抛出异常，会造成死循环，因为在init函数中，我们的Exception对象还没有构造好呢。

SmartPointer.h

#ifndef SMARTPOINTER_H
#define SMARTPOINTER_H

#include "Object.h"

namespace DTLib
{

template <typename T>
class SmartPointer : public Object
{
protected:
    T *m_pointer;

public:
    SmartPointer(T *p = NULL)
    {
        m_pointer = p;
    }

    SmartPointer(const SmartPointer<T>& obj)
    {
        m_pointer = obj.m_pointer;

        const_cast<SmartPointer<T>&>(obj).m_pointer = NULL;
    }

    SmartPointer<T>& operator= (const SmartPointer<T>& obj)
    {
        if(this != &obj)
        {
            delete m_pointer;

            m_pointer = obj.m_pointer;

            const_cast<SmartPointer<T>&>(obj).m_pointer = NULL;
        }

        return *this;
    }

    T* operator-> ()
    {
        return m_pointer;
    }

    T& operator* ()
    {
        return *m_pointer;
    }

    bool isNull()
    {
        return (m_pointer == NULL);
    }

    T* get()
    {
        return m_pointer;
    }

    ~SmartPointer()
    {
        delete m_pointer;
    }
};

}

#endif // SMARTPOINTER_H

main函数测试程序如下：

#include <iostream>
#include "Exception.h"
#include "Object.h"
#include "SmartPointer.h"
using namespace std;
using namespace DTLib;



int main()
{
    SmartPointer<int> *sp = new SmartPointer<int>();

    delete sp;

    return 0;
}

我们在Exception.cpp中new和delete重载的地方打上断点，执行程序结果如下：

   

可以看到，程序最终执行到了我们自己定义的new和delete处。

 DTLib的开发方式和注意事项：

迭代开发：

　　每次完成一个小的目标，持续开发，最终打造一个可复用类库

单一继承树：

　　所有类都继承自Object，规范堆对象创建时的行为

只抛异常，不处理异常：

　　使用THROW_EXCEPTION抛出异常，提高可移植性，有些老的编译器不支持异常，不支持try...catch...，或者有的公司规定不能使用异常机制，这时，如果还想使用

　　这个库，我们只需将这个宏定义为空

弱耦合性：

　　尽量不使用标准库中的类和函数，提高可移植性

 第一阶段的总结：

　　数据结构与算法之间的关系

　　算法效率的度量方法

　　DTLib的基础设施构建

　　　　顶层父类

　　　　智能指针

　　　　异常类