异常处理之一

1,局部对象清理.

#include <iostream>
using namespace std;

class A
{
public:
    A(){ cout<<"A()"<<endl; }
    ~A(){ cout<<"~A()"<<endl; }
};
void func()
{
    A a;
    cout<<"throw int exception."<<endl;
    throw 43;//"栈反解",清理临时对象a.
    cout<<"throw不会被执行了"<<endl;
}
int main()
{
    try{
        cout<<"try block!"<<endl;
        func();
    }
    catch(int)
    {
        cout<<"exception handler!"<<endl;
    }

    return 0;
}

2,异常匹配

#include <iostream>
using namespace std;

class Except1{};
class Except2
{
public:
    Except2(const Except1&){};
};
void func()
{
    throw Except1();
}
int main()
{
    try{
        func();
    }
    catch(Except2&) //不会发生隐式转换
    {
        cout<<"catch Except2."<<endl;
    }
    catch(Except1&) //参数写作异常类型的引用
    //防止派生类"切割";减少一次对象拷贝.
    {
        cout<<"catch Except1."<<endl;
    }

    return 0;
}

3.诱发terminate调用的三种情况:
(1)一个异常类型没有被任何一个语境层次的异常处理器捕获.
自定义termindate()函数.

#include <iostream>
using namespace std;

void my_terminate() //自定义的termindate()函数
{
    cout<<"without catching exception."<<endl;
    exit(0);
}

//改变terminate()函数,保存默认的函数.
void (*old_terminate)()=set_terminate(my_terminate);

void func(){ throw 43; }

int main()
{
    func(); //异常没有被捕获
    //导致terminate()函数的调用.
    return 0;
}

(2)"堆反解"过程中,局部对象的析构函数抛出了异常.

#include <iostream>
using namespace std;

class A
{
public:
    ~A(){ throw 43; }
};
void func()
{
    A a;
    cout<<"throw int exception."<<endl;
    throw 43;//"栈反解",清理临时对象a.
}
int main()
{
    try{
        func(); //清理a时,a的析构函数抛出了异常.
                //导致了terminate()函数的调用
    }
    catch(int)
    {
        cout<<"exception handler!"<<endl;
    }
    
    return 0;
}

(3)全局对象或静态对象的构造函数或析构函数中抛出了异常.

#include <iostream>
using namespace std;

class A
{
public:
    //A(){ throw 23; } //构造函数抛出异常.
    ~A(){throw 23; }
};
//A a; //全局对象,诱发terminate()函数的调用.
int main()
{
    try{
        static A a;//静态对象,诱发terminate()函数的调用.
    }
    catch(int)
    {
        cout<<"handle int exception."<<endl;
    }
    return 0;
}