异常类之派生类

上一节已经实现了异常基类的功能，接下来将实现基于该基类的几个父类

功能定义如下

异常类	功能描述
ArithmeticException	计算异常
NullPointerException	空指针异常
IndexOutOfBoundsException	越界异常
NotEnoughMemoryException	内存不足异常
InvalidParameterException	参数错误异常

为了代码简洁，定义一个宏

#define THROW_EXCEPTION(e, m) (throw e(m, __FILE__, __LINE__))//e为异常类类型

如果这个宏看不懂，就想一下throw函数的使用（可参见上一节）

 

要做的很简单，就是继承这个基类

完整代码如下

Exception.h

#ifndef _EXCEPTION_H_
#define _EXCEPTION_H_ 



namespace DataStructureLib
{
#define THROW_EXCEPTION(e,m) throw e(m,__FILE__,__LINE__)
class Exception
{
protected:
    char*  m_message;
    char*  m_location;
protected:
    void  init(const char*,const char*,int);//由于三个构造函数中的逻辑很相似，所以可以将相似的部分统一放到一个函数init()
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(void)= 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 NotEnoughMemoryException: public Exception
{
public:
    NotEnoughMemoryException():Exception(0){}
    NotEnoughMemoryException(const char* message):Exception(message){}
    NotEnoughMemoryException(const char*file, int line):Exception(file, line){}
    NotEnoughMemoryException(const char *message, const char* file, int line):Exception(message, file, line){}

    NotEnoughMemoryException(const NotEnoughMemoryException& e): Exception(e){}
    NotEnoughMemoryException& operator=(const NotEnoughMemoryException& 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;
    }
};

#endif
}

Exception.cpp

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

namespace DataStructureLib
{
void Exception::init(const char* message,const char* file,int line)
{
    m_message=strdup(message);//这里不能直接使用m_message=message，
                            //因为message指针指向的数据有可能会在栈、堆、全局区，如果是在栈上，局部变量可能会消失，如果直接使用m_message=message就会不安全    
    if(file!=NULL)
    {
        char sl[16]={0};
        itoa(line,sl,10);//将line转为char类型 10代表十进制

        m_location=static_cast<char* >(malloc(strlen(file)+strlen(sl)+2));//加2表示后面的"："和结束符即“/0”
        m_location=strcpy(m_location,file);
        m_location=strcat(m_location,":");
        m_location=strcat(m_location,sl);
    }
}

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(void)
{
    
    free(m_message);
    free(m_location);
}

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

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

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

}

测试

#include <iostream>
#include "Exception.h"
 
using namespace std;
using namespace DataStructureLib;

int main()
{
    try{
        THROW_EXCEPTION(NullPointerException,"test");
    }

    catch(const ArithmeticException& e)
    {
        cout<<"ArithmeticException "<<endl;
        cout<<e.location()<<endl;
        cout<<e.message()<<endl;
    }
    catch(const NullPointerException& e)
    {
        cout<<"NullPointerException"<<endl; 
        cout<<e.location()<<endl;
        cout<<e.message()<<endl;
    }

    catch(const Exception& e)
    {
        cout<<"Exception"<<endl;
        cout<<e.location()<<endl;
        cout<<e.message()<<endl;
    }
    
    system("pause"); 
    return 0;
}