c++异常处理

• try试图执行 try{}中的内容

• 在可能出现异常的地方 抛出异常 throw

• try下面 catch捕获异常

• catch(捕获类型)...代表 所有其他类型

• 如果不想处理异常，继续向上抛出 throw

• 如果没有任何处理异常的地方，那么成员调用terminate函数，使程序中断

  例：

int myDevide(int a, int b)
{

    if (b == 0)
    {
    //抛出int类型异常
        throw - 1;
    }
    return a / b;
};

void test()
{
    int a = 10;
    int b = 0;
    try
    {
        myDevide(a, b);
    }
    //处理int类型异常
    catch (int)
    {
    //throw; 再抛
        cout << "int类型异常捕获" << endl;
    }
    
}

自定义异常进行捕获

class myException
{
public:
    void printError()
    {
        cout << "自定义的异常" << endl;
    }
};
int myDevide(int a, int b)
{

    if (b == 0)
    {
        //抛出int类型异常
        throw myException();
    }
    return a / b;
};
void test()
{
    int a = 10;
    int b = 0;
    try
    {
        myDevide(a, b);
    }
    catch (int)
    {
        cout << "int类型异常捕获" << endl;
    }
    
    catch (myException e)
    {
        e.printError();
    }
}

栈解旋

从try开始 到throw抛出异常之前 所有栈上的对象都会被释放，这个过程称为栈解旋
栈上对象构造函数顺序和析构函数顺序相反

异常接口声明

• 为了加强程序的可读性，可以在函数声明中列出可能抛出异常的所有类型。例如：void func()throw(a,b,c);这个函数func能够且只能抛出类型a,b,c及其子类型的异常
• 如果在函数声明中包含异常接口声明，则函数可以抛任何类型的异常，例如：void func()
• 一个不抛任何类型异常的函数可声明为：void func()throw()
• 如果一个函数抛出了它的异常接口声明所不允许抛出的异常，unexcepted函数会被调用，该函数默认行为调用terminate函数中断程序

异常的生命周期

默认构造-->拷贝构造--->调异常方法--->析构拷贝出的异常类--->析构默认构造类

如果 myException e，会多开销一个数据，调用拷贝构造

如果myException *e,不new 提前释放对象，new自己管理delete

推荐myException &e,容易些，而且就一份数据

class myException
{
public:
    void printError()
    {
        cout << "自定义的异常" << endl;
    }
};
int myDevide(int a, int b)
{

    if (b == 0)
    {
        //抛出int类型异常
        throw myException();
    }
    return a / b;
};
void test()
{
    int a = 10;
    int b = 0;
    try
    {
        myDevide(a, b);
    }
    catch (int)
    {
        cout << "int类型异常捕获" << endl;
    }
    //这里会调用拷贝构造，会多异常开销
    catch (myException e)
    {
        e.printError();
    }
    /*
    这样不会调用拷贝构造
    catch (myException &e)
    {
        e.printError();
    }
    */
}

异常的多态使用

class BaseException

{

public:

virtual void printError()

{

}

};

class NullPointerException:public BaseException

{

public:

virtual void printError()

{

cout<<"空指针异常"<

使用系统标准异常类

#include 
throw out_of_range("aaa")...
catch(out_of_range &e) {cout<

编写自己的异常类

• 自己的异常类 需要继承于 exception
• 重写 虚析构 what()
• 内部维护以下错误信息 字符串
• 析构时候传入 错误信息字符串，what返回这个字符串
• string转char* 用c_str()

class MyOutofRangeException :public exception
{
public:
    MyOutofRangeException(string errorInfo)
    {
        ErrorInfo = errorInfo;
    }
    virtual ~MyOutofRangeException()
    {

    }
    virtual const char* what()const
    {
        return ErrorInfo.c_str();
    }
private:
    string ErrorInfo;
};
class Person
{
public:
    Person(string name, int age)
    {
        name = name;
        if (age < 0 || age>200)
        {
            throw MyOutofRangeException(string("年龄越界!"));
        }
        age = age;
    }
    string name;
    int age;
};

void test()
{
    try {
        Person p("大魔王", 1000);
    }
    catch (MyOutofRangeException& e)
    {
        cout<