异常类之基类

1.C++中的异常

C++异常处理语法元素try-catch语句

• try语句处理正常代码逻辑  （但有可能产生异常，产生异常时抛出异常并转到catch语句块里面的代码）
  
• catch语句处理异常情况
  
• try语句中的异常由对应的catch语句处理
  
• C++通过throw语句抛出异常信息（一般在try语句中）

throw和return区别

throw异常的返回一个值，这个值就代表了异常，   抛到catch语句块 

return正常的返回一个值

 

C++异常处理分析

（1）throw抛出的异常必须被catch处理

• 当前函数能够处理异常（含有catch语句块），程序继续往下执行
  
• 当前函数无法处理异常，则函数停止执行，并返回，由上层函数进行处理了。
  

（2）未被处理的异常会顺着函数调用栈向上传播，直到被处理为止，否则程序将停止执行。如果一直未处理则会到main函数，该函数中若果仍没有try..catch语句直接退出

 

（3）同一个try语句可以跟上多个catch语句

　　①catch语句可以定义具体处理的异常类型

　　②不同类型的异常由不同的catch语句负责处理。

　　③try语句中可以抛出任何类型的异常

　　④catch(…)用于处理所有类型的异常

　　⑤任何异常都只能被捕获（catch）一次。

（4）异常处理的匹配规则

 

#include <iostream>

using namespace std;

double divide(double a, double b)
{
    const double delta = 0.000000000000001;
    double ret = 0;

    if( !((-delta < b) && ( b < delta))){
        ret = a / b;
    }else{
        throw 0; //产生除0异常
    }

    return ret;
}

//匹配规则（自上而下，严格匹配、不进行类型转换）
void Demo1()
{
    try{
        throw 'c';  //抛出字符型的异常
    }catch(int i){
        cout << "catch(int i)" << endl;
    }catch(double d){
        cout << "catch(double d)" << endl;
    }catch(char c){ //只能被这里的catch捕获
        cout << "catch(char c)" << endl;
    }
}

void Demo2()
{
    throw "Demo2";   //const char*
}
int main()
{
    cout << "main() begin" << endl;

    try{
        double c = divide(1, 0);//产生异常
        cout <<"c = " << c << endl; //无法被执行到！
    }catch(...){
        cout << "Divide by zero..." << endl;
    }

    Demo1();

    try{
        Demo2();
    } 
      catch(char* c)
     {
        cout << "catch(char* c)" << endl;
    }
    catch(const char* c)
        {
        cout << "catch(const char* c)" << endl;
    }catch(...)
     {
       //写位置最后
        cout << "catch(...)" << endl;
    }

    cout << "main() end" << endl;
    return 0;
}

2.异常类的构建

• 异常的类型可以是自定义的类类型
• 对于类类型异常的匹配依旧是至上而下严格匹配（不能强制类型的转换）
• 赋值兼容性原则（子类的对象可以直接复制给父类的对象，父类的指针可以直接指向子类的对象）在异常匹配中依然使用 （出现父类对象是可以用一个子类对象代替）
  
• 一般而言：

    ------匹配子类异常的catch放在上部

    ------匹配父类异常的catch放在下部

3、异常类族

现代C++库必然包含充要的异常类族 

异常类族是数据结构类所以来的“基础设施”

 

 顶层父类Exception是一个抽象类，不能定义对象，用于被继承的。

这一节就是实现这个抽象基类的。

目的：当程序抛出异常时（有可能会是一个字符串、文件名、行号），能够捕捉到这个异常，并打印处异常的信息等。

要实现的几个函数：

构造函数：对收到的异常进行初始化工作

    Exception(const char* message); 
    Exception(const char* file,int line);
    Exception(const char* message,const char* file,int line);

由于初始化工作差不多，为了代码整洁我们将相同的操作封装成了一个函数即：

void  init(const char*,const char*,int);//由于三个构造函数中的逻辑很相似，所以可以将相似的部分统一放到一个函数init()

此外还需要保存一些初始化变量的成员变量

char* m_message;//m_message指向一个字符串，用于说明当前的异常信息
char* m_location;//m_location指向一个字符串，用于说明当前的异常位置

由于涉及到堆空间即需进行深拷贝，就不能使用默认的拷贝构造函数和赋值操作符，需要自己定义实现即

//涉及到堆空间即需进行深拷贝，拷贝构造函数和"="
    Exception(const Exception& e);
    Exception& operator =(const Exception& e);

完整代码如下

Exception.h 

#ifndef _EXCEPTION_H_
#define _EXCEPTION_H_ 
namespace DataStructureLib
{

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);
};
#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 "SmartPointer.h"
#include "Exception.h"

using namespace std;
using namespace DataStructureLib;

int main(int argc,char* argv[])
{    
    try
    {
        throw(Exception("test",__FILE__,__LINE__));
    }
    catch (const Exception& e)
    {
        cout<<e.message()<<endl;
        cout<<e.location()<<endl;
    }

    return 0;
} 

 

结果：