异常处理

异常的基本思想是：让一个函数在发现了自己无法处理的错误时抛出（throw）一个异常，然后它的（直接或者间接）调用者能够处理这个问题。也就是《C++ Primer》中说的：将问题检测和问题处理相分离。

一种思想：在所有支持异常处理的编程语言中（例如java），要认识到的一个思想：在异常处理过程中，由问题检测代码可以抛出一个对象给问题处理代码，通过这个对象的类型和内容，实际上完成了两个部分的通信，通信的内容是“出现了什么错误”。当然，各种语言对异常的具体实现有着或多或少的区别，但是这个通信的思想是不变的。

一句话：异常处理就是处理程序中的错误。所谓错误是指在程序运行的过程中发生的一些异常事件（如：除0溢出、数组下标越界、所要读取的文件不存在、空指针、内存不足等等）。

回顾一下：我们以前编写程序是如何处理异常？

在C语言的世界中，对错误的处理总是围绕着两种方法：一是使用整型的返回值标识错误；二是使用errno宏（可以简单的理解为一个全局整型变量）去记录错误。当然C++中仍然是可以用这两种方法的。

这两种方法最大的缺陷就是会出现不一致问题。例如有些函数返回1表示成功，返回0表示出错；而有些函数返回0表示成功，返回非0表示出错。

还有一个缺点就是函数的返回值只有一个，你通过函数的返回值表示错误代码，那么函数就不能返回其他的值。当然，你也可以通过指针或者C++的引用来返回另外的值，但是这样可能会令你的程序略微晦涩难懂。

C++异常机制相比C语言异常处理的优势?

• 函数的返回值可以忽略，但异常不可忽略。如果程序出现异常却没有被捕获，程序就会终止，这多少会促使程序员开发出来的程序更健壮一点。而如果使用C语言的error宏或者函数返回值，调用者都有可能忘记检查，从而没有对错误进行处理，结果造成程序莫名其面的终止或出现错误的结果。

• 整型返回值没有任何语义信息。而异常却包含语义信息，有时你从类名就能够体现出来。

• 整型返回值缺乏相关的上下文信息。异常作为一个类，可以拥有自己的成员，这些成员就可以传递足够的信息。

• 异常处理可以在调用跳级。这是一个代码编写时的问题：假设在有多个函数的调用栈中出现了某个错误，使用整型返回码要求你在每一级函数中都要进行处理。而使用异常处理的栈展开机制，只需要在一处进行处理就可以了，不需要每级函数都处理。

如果判断返回值，那么返回值是错误码还是结果？ 如果不判断返回值，那么 b==0 时候，程序结果已经不正确

//A写的代码
int A_MyDivide(int a, int b) {
    if (b == 0) {
        return -1;
    }

    return a / b;
}

//B写的代码
int B_MyDivide(int a, int b) {
    int ba = a + 100;
    int bb = b;

    int ret = A_MyDivide(ba, bb);//由于B没有处理异常，导致B结果运算错误

    return ret;
}

//C写的代码
int C_MyDivide() {
    int a = 10;
    int b = 0;

    int ret = B_MyDivide(a, b);//更严重的是，由于B没有继续抛出异常，导致C的代码没有办法捕获异常
    if (ret == -1) {
        return -1;
    } else {
        return ret;
    }
}

所以,我们希望：

1. 异常应该捕获，如果你捕获，可以，那么异常必须继续抛给上层函数,你不处理，不代表你的上层不处理
2. 这个例子，异常没有捕获的结果就是运行结果错的一塌糊涂，结果未知，未知的结果程序没有必要执行下去

异常基本语法

int A_MyDivide(int a, int b){
    if (b == 0){
        throw 0;
    }

    return a / b;
}

//B写的代码 B写代码比较粗心，忘记处理异常
int B_MyDivide(int a, int b){
    int ba = a;
    int bb = b;

    int ret = A_MyDivide(ba, bb) + 100;  //由于B没有处理异常，导致B结果运算错误

    return ret;
}

//C写的代码
int C_MyDivide(){
    int a = 10;
    int b = 0;

    int ret = 0;

//没有处理异常，程序直接中断执行
#if 1 
    ret = B_MyDivide(a, b);

//处理异常
#else 
    try{
        ret = B_MyDivide(a, b); //更严重的是，由于B没有继续抛出异常，导致C的代码没有办法捕获异常
    }
    catch (int e){
        cout << "C_MyDivide Call B_MyDivide 除数为:" << e << endl;
    }
#endif
    
    return ret;
}

int main(int argc, char *argv[]){
    C_MyDivide();

    return 0;
}

总结:

• 若有异常则通过throw操作创建一个异常对象并抛出。

• 将可能抛出异常的程序段放到try块之中。

• 如果在try段执行期间没有引起异常，那么跟在try后面的catch字句就不会执行。

• catch子句会根据出现的先后顺序被检查，匹配的catch语句捕获并处理异常(或继续抛出异常)

• 如果匹配的处理未找到，则运行函数terminate将自动被调用，其缺省功能调用abort终止程序。

• 处理不了的异常，可以在catch的最后一个分支，使用throw，向上抛。

C++异常处理使得异常的引发和异常的处理不必在一个函数中，这样底层的函数可以着重解决具体问题，而不必过多的考虑异常的处理。上层调用者可以在适当的位置设计对不同类型异常的处理。

异常严格类型匹配

异常机制和函数机制互不干涉，但是捕捉方式是通过严格类型匹配。

void TestFunction(){
    cout << "开始抛出异常..." << endl;
    //throw 10; //抛出int类型异常
    //throw 'a'; //抛出char类型异常
    //throw "abcd"; //抛出char*类型异常
    string ex = "string exception!";
    throw ex;

}

int main(int argc, char *argv[]){
    try{
        TestFunction();
    }
    catch (int){
        cout << "抛出Int类型异常!" << endl;
    }
    catch (char){
        cout << "抛出Char类型异常!" << endl;
    }
    catch (char*){
        cout << "抛出Char*类型异常!" << endl;
    }
    catch (string){
        cout << "抛出string类型异常!" << endl;
    }
    //捕获所有异常
    catch (...){
        cout << "抛出其他类型异常!" << endl;
    }

    return 0;
}

栈解旋

异常被抛出后，从进入try块起到异常被抛掷前，这期间在栈上构造的所有对象，都会被自动析构。析构的顺序与构造的顺序相反，这一过程称为栈的解旋(unwinding)。

class Person{
public:
    Person(string name){
        mName = name;
        cout << mName << "对象被创建!" << endl;
    }
    ~Person(){
        cout << mName << "对象被析构!" << endl;
    }
public:
    string mName;
};

void TestFunction(){
    Person p1("aaa");
    Person p2("bbb");
    Person p3("ccc");

    //抛出异常
    throw 10;
}

int main(int argc, char *argv[]){
    try{
        TestFunction();
    }
    catch (...){
        cout << "异常被捕获!" << endl;
    }

    return 0;
}

异常接口声明

• 为了加强程序的可读性，可以在函数声明中列出可能抛出异常的所有类型，例如：void func() throw(A,B,C);这个函数func能够且只能抛出类型A,B,C及其子类型的异常。

• 如果在函数声明中没有包含异常接口声明，则此函数可以抛任何类型的异常，例如:void func()

• 一个不抛任何类型异常的函数可声明为:void func() throw()

• 如果一个函数抛出了它的异常接口声明所不允许抛出的异常，unexcepted函数会被调用，该函数默认行为调用terminate函数中断程序。

//可抛出所有类型异常
void TestFunction01(){
    throw 10;
}

//只能抛出int char char*类型异常
void TestFunction02() throw(int,char,char*){
    string exception = "error!";
    throw exception;
}

//不能抛出任何类型异常
void TestFunction03() throw(){
    throw 10;
}

int main(int argc, char *argv[]){
    try{
        //TestFunction01();
        //TestFunction02();
        //TestFunction03();
    }
    catch (...){
        cout << "捕获异常!" << endl;
    }
    
    return 0;
}

分别在QT、Visual Studio、Linux下做测试！Qt and Linux 正确!

异常变量生命周期

• throw的异常是有类型的，可以是数字、字符串、类对象。

• throw的异常是有类型的，catch需严格匹配异常类型。

class MyException {
public:
    MyException() {
        cout << "异常变量构造" << endl;
    };
    MyException(const MyException &e) {
        cout << "拷贝构造" << endl;
    }
    ~MyException() {
        cout << "异常变量析构" << endl;
    }
};
void DoWork() {
    throw new MyException();//test1 2都用 throw MyExecption();
}

void test01() {
    try {
        DoWork();
    } catch (MyException e) {
        cout << "捕获 异常" << endl;
    }
}
void test02() {
    try {
        DoWork();
    } catch (MyException &e) {
        cout << "捕获 异常" << endl;
    }
}

void test03() {
    try {
        DoWork();
    } catch (MyException *e) {
        cout << "捕获 异常" << endl;
        delete e;
    }
}

异常的多态使用

#include <iostream>

//异常基类
class BaseException{
public:
    virtual void printError(){};
};

//空指针异常
class NullPointerException : public BaseException{
public:
    virtual void printError(){
        std::cout << "空指针异常!" << std::endl;
    }
};
//越界异常
class OutOfRangeException : public BaseException{
public:
    virtual void printError(){
        std::cout << "越界异常!" << std::endl;
    }
};

void doWork(){

    throw NullPointerException();
}

void test()
{
    try{
        doWork();
    }
    catch (BaseException& ex){
        ex.printError();
    }
}

int main(int argc, char *argv[]){
    test();
    
    return 0;
}

程序输出：

空指针异常!