异常类的构建——顶层父类Exception的实现

class Exception
{
protected:
　　char* m_message;
　　char* m_location;
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;
};

#ifndef EXCEPTION_H
#define EXCEPTION_H

namespace DTLib
{
class Exception
{
protected:
    char* m_location;
    char* m_message;
    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 ; //纯虚析构函数，纯虚函数需要提供实现吗？纯虚函数是不需要提供实现的，等待子类去实现。但是这个地方是个例外，C++规定只要自定义了析构函数，不管
                              //这个析构函数是不是纯虚函数，一定要提供实现。为什么？在析构一个对象的时候，最后肯定会调用到父类的析构函数，
};

}

#endif // EXCEPTION_H

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

namespace DTLib
{
void Exception::init(const char *message, const char *file, int line)
{
    //m_message = message; //直接进行这样的赋值，这样写可以吗？肯定不行，因为参数的message这个指针它指向的字符串有可能在栈上，有可能在堆空间中，还有可能在全局数据区。
                         //这样的话，没有办法控制message所指向的外部字符串的生命周期，所以说这样的写法是不安全的。可以拷贝一份字符串出来。
    m_message = strdup(message);  //将字符串复制到了堆空间。

    if(file != NULL)
    {
        char sl[16] = {0};
        itoa(line,sl,10);   //itoa在linux下是无法使用的，需要使用sprintf

        //m_location = malloc(strlen(file) + strlen(sl) + 2);  //malloc函数返回的是void*,将void*直接赋值给char*是不可以的。因此需要进行强制类型转换。使用static_cast
        m_location = static_cast<char*>(malloc(strlen(file) + strlen(sl) + 2));
        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_location = strdup(e.m_location);
    m_message = strdup(e.m_message);
}
Exception& Exception::operator= (const Exception& e)
{
    if(this != &e)
    {
        free(m_location);
        free(m_message);
        m_location = strdup(e.m_location);
        m_message = strdup(e.m_message);
    }

    return *this;
}

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

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

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

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

using namespace std;
using namespace DTLib;


int main()
{
    try
    {
        throw Exception("test", __FILE__,__LINE__);  //将析构函数定义成了纯虚函数，是不能定义对象的，为了测试，先将纯虚去掉。
    }
    catch(const Exception& e)
    {
        cout << " catch(const Exception& e)" << endl;
        cout << e.message() << endl;
        cout << e.location() << endl;
    }
    return 0;
}

namespace DTLib
{
#define THROW_EXCEPTION(e,m) (throw e(m, __FILE__,__LINE__))

class Exception

 try
    {
        THROW_EXCEPTION(Exception,"test");  //为了测试，还需要将纯虚特性去掉
    }