第9课 C++异常处理机制

#include <iostream>
#include <string>
using namespace std;

class MyException
{
public:
    MyException() { cout << "MyException():" << this << endl; }
    MyException(const MyException&) { cout << "MyException(const MyException&):" << this << endl; }

    ~MyException() { cout << "~MyException():" << this << endl; }

    void what() { cout << "MyException: this = " << this << endl; }
};

class MyChildExcept : public MyException
{
public:
    MyChildExcept() { cout << "MyChildExcept():" << this << endl; }
    MyChildExcept(const MyChildExcept&) { cout << "MyChildExcept(const MyChildExcept&):" << this << endl; }

    ~MyChildExcept() { cout << "~MyChildExcept():" << this << endl; }

    void what() { cout << "MyChildExcept: this = " << this << endl; }
};

void func_local()
{
    // throw 局部对象
    MyException localEx;
    throw localEx;   //尽管localEx是个局部对象，但这里会将其复制构造出一个异常对象，并存储在TIB中。而不是真正的将局部对象抛出去！
}

void func_temp()
{
    //throw 临时对象
    MyException();       //临时对象1
    throw MyException(); //编译器会将这个临时对象直接存储在线程TIB中，成为异常对象（注意与临时对象1存储位置一般相距较远！）
}

void func_ptr()
{
    //throw 指针
    throw new MyException(); //注意：异常对象是复制的堆对象而来的指针（存在内存泄漏风险！！！）
}

void func_again()
{
    MyChildExcept child;
    MyException& re = child; //注意抛出的是re的静态类型的异常对象，即MyException，而不是MyChildExcept;
    throw re;
}

int main()
{
    cout << "----------------------------------catch by value------------------------------" << endl;
    //按值捕获
    try {
        func_local();        //throw MyExecption()
    }
    catch (MyException e) {  //复制异常对象，须额外进行一次拷贝！
        cout << "catch (MyException e)" << endl;
        e.what();
    }

    cout << "--------------------------------catch by reference----------------------------" << endl;
    //按引用捕获
    try {
        func_temp();
    }
    catch (MyException& e) { //直接引用异常对象，无须拷贝
        cout << "catch (MyException& e)" << endl;
        e.what();
    }

    cout << "---------------------------------catch by pointer-----------------------------" << endl;
    //按指针捕获
    try {
        func_ptr();
    }
    catch (MyException* e) { //按指针捕获（可能造成内存泄漏）
        cout << "catch (MyException* e)" << endl;
        e->what();
        delete e;  //释放堆对象，防止内存泄漏
    }

    cout << "------------------------------------throw again-------------------------------" << endl;
    //二次抛异常
    try {
        try {
            func_again();
        }
        catch (MyException& e) {
            e.what();

            //注意以下两种方式不同
            //1. 在throw后指定异常对象为e
            //throw e; //e会继续复制一份，并抛出复制的异常对象而e本身会被释放！

            //2.throw后不指定任何对象，只要是在catch中捕获的，一律抛出去。
            throw;    //此时，e本身再被抛出去。不会另外构造异常对象。
        }
    }
    catch (MyException& e) {
        e.what();
    }

    return 0;
}


/*输出结果(g++编译环境下的输出）
----------------------------------catch by value------------------------------
MyException():0x61fe7f    //localEx对象
MyException(const MyException&):0x29978f8   //throw时将localEx复制给异常对象
~MyException():0x61fe7f   //释放localEx
MyException(const MyException&):0x61feaf    //将异常对象复制给catch中的e对象
catch (MyException e)
MyException: this = 0x61feaf
~MyException():0x61feaf      //释放catch中的e对象
~MyException():0x29978f8     //释放异常对象
--------------------------------catch by reference----------------------------
MyException():0x61fe7f   //创建临时对象1
~MyException():0x61fe7f  //释放临时对象1
MyException():0x29978f8  //throw MyException()时，会将这个临时对象直接创建在TIB中，与临时对象1不在同一地址段中
catch (MyException& e)   //按引用传递，e直接引用异常对象，少了一次拷贝
MyException: this = 0x29978f8
~MyException():0x29978f8  //释放异常对象
---------------------------------catch by pointer-----------------------------
MyException():0x299c638   //throw new Exception() ,先在堆中创建一个Exception对象，再将指针throw出去。
catch (MyException* e)
MyException: this = 0x299c638
~MyException():0x299c638   //手动调用delete后，释放堆中的Exception对象。
------------------------------------throw again-------------------------------
MyException():0x61fe7b
MyChildExcept():0x61fe7b
MyException(const MyException&):0x29978f8  //异常对象，这里是re的静态类型，即MyException,而不是MyChildExcept!!!
~MyChildExcept():0x61fe7b
~MyException():0x61fe7b
MyException: this = 0x29978f8  //内层catch到的异常对象
MyException: this = 0x29978f8  //外层catch到的异常对象，注意与内层是同一对象
~MyException():0x29978f8   //释放异常对象
*/

#include <iostream>
#include <type_traits>
using namespace std;

//以下两个函数不能构成重载
//void func(int) noexcept(true){}
//void func(int) noexcept(false){}

//1. 异常规格与函数指针
void func1(int) noexcept(true) {};        //不抛出异常
void func2(int) noexcept(false) {}; //可能抛出异常
void func3(int){}

//2. noexcept与虚函数
class Parent
{
public:
    virtual void func1() noexcept {}      //不抛异常
    virtual void func2() noexcept(false) {} //可能抛异常
};

class Child : public Parent
{
public:
    //基类承诺不抛异常，则子类也必须承诺！
    //void func1() {};  //error, Parent::func1() 承诺不抛异常了

    //基类声明为可能抛异常，则子类可以抛，也可以不抛异常
    void func2() noexcept(true) {} //ok, 子类不抛异常
    //void func2() {};     //ok，子类可以抛异常
};

//3. 有条件的noexcept
//3.1 Swap:交互两个数组的元素。
//只要交互元素时不抛异常，但交换整个数组就不抛异常。因此Swap函数是否为noexcept取决于交互元素
template<typename T, size_t N>
void Swap(T(&a)[N], T(&b)[N]) noexcept(noexcept(std::swap(*a, *b))) //*a、*b为首元素
{
    for (int i = 0; i < N; ++i) {
        std::swap(a[i], b[i]);
    }
}
template<typename T, size_t N>
void printArray(T(&a)[N])
{
    for (int i = 0; i < N; ++i) {
        cout << a[i] << " ";
    }
    cout << endl;
}

//3.2 func
//func_destructor函数抛不抛异常取决于T的析构函数。如果T析构会抛异常则func_destructor也会抛异常，反之不抛异常。
template<typename T>
void func_destructor(const T&) noexcept(noexcept((std::declval<T>().~T()))) {} 

struct CA
{
    ~CA(){ throw 1; } //注意析构函数默认为noexcept(true)
};

struct CB
{
    ~CB()noexcept(false){ throw 2; }
};

struct CC
{
    CB b;
};

//3.3 pair
template<class T1, class T2>
class MyPair
{
    T1 first;
    T2 second;
public:

    //swap函数是否为noexcept，取决于交互first和second的过程是否为noexcept
    void swap(MyPair& p) noexcept(noexcept(std::swap(first, p.first)) &&
                                  noexcept(std::swap(second, p.second)))
    {
    }
};

//4. noexcept
void Throw() { throw 1; }        //可能抛异常：异常会被向外层传递出去
void NoBlockThrow() { Throw(); } //可能抛异常：异常会被向外层传递出去
void BlockThrow() noexcept { Throw(); } //不抛异常，但此函数实际会抛异常，异常会阻止传递，程序中止

int main()
{
    //1. noexcept与函数指针
    //1.1规则1：
    void(*pf1)(int) noexcept = func1; //正确
    //void(*pf2)(int) noexcept = func2; //error;异常规格不同！
    //void(*pf3)(int) noexcept = func3; //error，带noexcept的指针，只能指向带同种noexcept规格的函数

    //1.2 规则2：
    void(*pf4)(int) = func1;  //or，pf3未带noexcept，可以指向任何函数
    void(*pf5)(int) = func2;  //ok
    void(*pf6)(int) = func3;  //ok

    //2. noexcept与虚函数（见Child类）

    //3. 有条件的noexcept

    //3.1 交换数组
    int a[] = { 1,2,3,4,5 };
    int b[] = { 6,7,8,9,10 };

    Swap(a, b); //Swap函数是否为noexcept，取决于std::swap(*a,*b)函数是否为noexcept
    printArray(a);
    printArray(b);

    //3.2 析构函数
    try {
        CB temp;
        func_destructor(temp); //分别测试CA, CB, CC类。此处，由于CB析构函数为可能抛出异常，因此
                               //抛出会被继续抛出而被catch(...)语句捕获，程序不会被中止
    }
    catch (...) {
        cout << "catch destructor exception" << endl;
    }

    //4. noexcept与异常传递测试
    try {
        Throw(); //这里可增加测试NoBlockThrow、BlockThrow函数
    }catch (...) {
        cout <<"catch exception..." << endl;
    }

    return 0;
}
/*输出结果：
6 7 8 9 10
1 2 3 4 5
catch destructor exception
catch exception...
*/