C++回顾day03---<异常>

一：传统错误处理机制（C中通过函数返回来处理）

int CalcRes(int n, int m, char ch, int& res)
{
    int err = 0;
    switch (ch)
    {
    case '+':
        res = n + m;
        break;
    case '-':
        res = n - m;
        break;
    case '/':
        if (m == 0)
            err = -1;
        res = 0;
        break;
    case '*':
        res = n*m;
        break;
    }

    return err;
}

void main()
{
    int res,err;
    err = CalcRes(5, 0, '/', res);
    if (err == -1)
        cout << "calculate error:divide 0" << endl;
    system("pause");
}

二：异常处理基本思想

（一）C++异常处理机制使得异常的引发和处理不必过度关注。上层调用者只需要在适当的位置设置对不同类型异常的处理

传统的错误处理，通过返回值判断出错，进行处理，或者一步步向上返回错误码，十分复杂。而异常处理机制只需要在适当位置进行出错捕获可以进行错误处理

（二）异常是专门针对抽象编程中的一系列错误处理的，C++不需要借助函数机制（向C传统错误处理，逐函数返回，无法进行跳跃）

（三）异常超脱于函数机制（函数之间调用需要压栈出栈操作），遇到异常抛出，可以跨越式回跳，而不需要逐级出栈处理。

（四）C++异常跨越式回跳：代码实现

int CalcRes(int n, int m, char ch, int& res)
{
    int err = 0;
    switch (ch)
    {
    case '+':
        res = n + m;
        break;
    case '-':
        res = n - m;
        break;
    case '/':
        if (m == 0)
            throw n;    //抛出int异常
        res = 0;
        break;
    case '*':
        res = n*m;
        break;
    }

    return err;
}

void t3()
{
    int res;
    CalcRes(5, 0, '/', res);　　//若是异常抛出后会跨越式会跳--->那么后面的红色代码不会显示，因为不会按出栈方式继续执行
    cout << "t3" << endl;
}

void t2()
{
    t3();
    cout << "t2" << endl;
}

void t1()
{
    t2();
    cout << "t1" << endl;
}

void main()
{
    try
    {
        t1();
    }
    catch (int n)
    {
        cout << n << endl;
    }
    system("pause");
}

三：C++异常处理的实现

（一）抛出异常: throw  表达式;

void func()
{
    ...
    throw 表达式;
    ...
}

（二）捕获并处理异常：try...catch...

try
{
    捕获代码块
    例如：调用func()
}
catch(异常类型声明)
{
    异常处理语句
}
catch(类型  (形参))
{
    ...
}
...

（三）异常处理步骤

1.若有异常：可以通过throw操作创建一个异常对象并抛出

2.将可能有异常的代码段嵌入try块进行捕获。

3.若是没有抛出异常，则跳过catch语句继续向下执行

4.若是捕获到异常抛出，则执行相关catch语句处理异常，或者若是玉带处理不了的异常可以继续throw向上抛出。

5.若是到最后，匹配的处理器都未找到，则会调用系统函数terminate（调用abort终止程序）

（四）案例一：正常捕获异常

int divide(int x, int y)
{
    if (y == 0)
        throw x;    //抛出int整型异常
    return x / y;
}

void main()
{
    try
    {
        cout << "8/2=" << divide(8, 2) << endl;
        cout << "5/0=" << divide(5, 0) << endl;
    }
    catch (int e)    //捕获int整型异常
    {
        cout << e << " is divide by zero" << endl;
    }
    catch (...)    //...是捕获所有异常
    {
        cout << "catch all exception" << endl;
    }
    system("pause");
}

（五）案例二：异常未捕获，触发系统调用abort终止

class A
{

};

int divide(int x, int y)
{
    if (y == 0)
        throw A();    //抛出A类异常
    return x / y;
}

void main()
{
    try
    {
        cout << "8/2=" << divide(8, 2) << endl;
        cout << "5/0=" << divide(5, 0) << endl;
    }
    catch (int e)    //捕获int整型异常
    {
        cout << e << " is divide by zero" << endl;
    }
    //catch(A)    //未捕获
    system("pause");
}

（六）修改系统默认行为set_terminate--->可以用catch(...)捕获全部，来代替

#include <exception>

class A
{

};

int divide(int x, int y)
{
    if (y == 0)
        throw A();    //抛出A类异常
    return x / y;
}

void my_Terminate()
{
    cout << "exec myself terminate" << endl;
    exit(-1);
}

void main()
{
    set_terminate(my_Terminate);    //修改系统默认行为（会在系统调用abort之前执行，若是这里异常还没有被处理，那么还是会调用abort）
    try
    {
        cout << "8/2=" << divide(8, 2) << endl;
        cout << "5/0=" << divide(5, 0) << endl;
    }
    catch (int e)    //捕获int整型异常
    {
        cout << e << " is divide by zero" << endl;
    }
    //catch(A)    //未捕获
    system("pause");
}

在vs下未实现，vc++似乎可以实现代码。所以我们一般不要使用它

（七）捕获严格按照抛出类型匹配

例如：
throw int;
catch(char);是无法捕获的

四：栈解旋

在异常被抛出后，即throw异常，之后会对栈上的所有对象进行自动析构。析构顺序与构造相反，这一过程叫做栈的解旋

class A
{
public:
    A()
    {
        cout << "A construct" << endl;
    }

    ~A()
    {
        cout << "A distruct" << endl;
    }
};

class B
{
public:
    B()
    {
        cout << "B costruct" << endl;
    }

    ~B()
    {
        cout << "B distruct" << endl;
    }
};

void divide(int n, int m)
{
    B b;    //对象二后入栈
    if (m == 0)
        throw n;
}

void t1()
{
    A a;    //对象一先入栈
    divide(5, 0);
}


void main()
{
    try
    {
        t1();
    }
    catch (int e)
    {
        cout << e << " divide zeor is err" << endl;
    }

    system("pause");
}

五：异常接口声明

（一）为了增强程序的可读性，可以在函数声明中列出可能抛出的所有异常类型（也只能抛出这几个类型）

void func() throw(A,B,C,D);    //这个函数只能抛出这几个类型

（二）若是函数声明中没有包含任何异常接口声明，那么这个函数可以抛出任何类型的异常

（三）一个不允许抛出任何异常的函数

void func() throw();

（四）若是一个函数抛出了他的异常接口所不允许的异常，unexpected函数会被调用，该函数默认行为会调用terminate函数终止程序

 六：异常类型和异常变量的生命周期

（一）throw的异常是有类型的，可以是数字,字符串,类对象,字符...。

void t1(int flag)    throw(int,char,double,char*,A)    //进行异常接口声明
{
    if (flag == 0)
        throw 1;    //抛出整型
    else if (flag == 1)
        throw "string throw";    //抛出字符串
    else if (flag == 2)
        throw 'c';    //抛出字符
    else if(flag == 3)
　　　　 throw 1.1;
    else
        throw A();    //抛出类对象
}


void main()
{
    try
    {
        //t1(0);
        //t1(1);
        //t1(2);
        t1(3);
    }
    catch (int e)
    {
        cout << e << endl;
    }
    catch (char c)
    {
        cout << c << endl;
    }
    catch (char* s)
    {
        cout << s << endl;
    }
　 catch(double b)
　 {
        cout<<b<<endl;
    }

    catch (A a)
    {
        cout << "catch obj a" << endl;
    }
}

（二）异常变量的生命周期（异常变量周期会在throw之后被释放，catch获取的是一个新的拷贝变量）

七：标准异常类

基类Exception中提供了一个what函数，用于返回错误信息,返回类型const char*
函数声明类型：
virtual const char* what() const throw();

（一）标准异常类的继承关系

其中runtime_error是运行时异常，难以检测。
logic_error是逻辑错误，可能IDE都会检测出来，易发现

logic_error和runtime_error两个类及其派生类都有一个接受const string&形参的构造函数---->说明我们可以自己写错误提示信息

（二）异常类所在的头文件和含义

（三）标准异常类的使用（模拟一个）

class A
{
public:
    A(int a)
    {
        if (a > 100)
            throw out_of_range("age to long");
    }

    ~A()
    {
        cout << "A distruct" << endl;
    }
};


void main()
{
    try
    {
        A a(101);
    }
    catch (out_of_range e)
    {
        cout << e.what();
    }

    system("pause");
}

（四）注意：使用exception &e只能捕获其基类为Exception及其子类的所有异常。所以要捕获所有异常可以使用catch(...)更好(但是没有what方法，可以自己定义)