异常

C语言错误处理方法

• 返回值（if…else语句判断错误）
• errno
• goto语句
• setjmp、longjmp（这种跳转不会调用对象析构函数，因为对象不能被正常清理）
• C语言的出错处理是被认为是紧耦合的，函数的使用者必须在非常靠近函数调用的地方编写错误处理代码，这会使得其变得笨拙以及难以使用

程序错误

• 编译错误
  即语法错误，程序就无法被生成运行代码。
• 运行时错误
  
  • 不可预料的逻辑错误
  • 可以预料的运行异常

异常语法

try
{
    //try语句块             //throw <表达式>
}
catch (类型1 参数1)
{
    //针对类型1的异常处理
}
catch (类型2 参数2)
{
    //针对类型2的异常处理
}
...
catch (类型n 参数n)
{
    //针对类型n的异常处理
}

异常抛出

• 可以抛出内置类型的异常，也可以抛出自定义类型异常
• throw抛出一个类对象会调用拷贝构造函数
• 异常发生之前创建的局部对象被销毁，这一过程称为栈展开

#include <iostream>
#include <string>

using namespace std;

class MyException
{
public:
    MyException(const char* message) : message_(message) 
    {
        cout << "MyException ..." << endl;
    }
    MyException(const MyException& other) : message_(other.message_)
    {
        cout << "Copy MyException ..." << endl;
    }
    ~MyException() 
    {
        cout << "~MyException ..." << endl;
    }
    const char* What() const
    {
        return message_.c_str();
    }
private:
    string message_;
};
double Devide(double a, double b)
{
    if (b == 0.0)
    {
        MyException e("devision by zero .");
        throw e;                        //调用拷贝构造函数
    }
    else
        return a / b;
}

int main(void)
{
    try
    {
        cout << Devide(5.0, 0.0) << endl;
    }
    catch (MyException& e)
    {
        cout << e.What() << endl;
    }
}

异常捕获

• 一个异常处理器一般只捕获一种类型的异常
• 异常处理器的参数类型和抛出异常类型的类型相同
• … 表示可以捕获任何异常

异常传播

• try块可以镶嵌
• 程序按顺序寻找匹配的异常处理器，抛出的异常将被第一个类型符合的异常处理器捕获
• 如果内层try块后面没有找到合适的异常处理器，该异常向外传播，到外层try块后面的catch块中寻找
• 没有被捕获的异常将调用terminate函数，terminate函数默认调用abort终止程序的执行
• 可以使用set_terminate函数指定terminate函数将调用的函数

#include <iostream>
#include <string>

using namespace std;

class MyException
{
public:
    MyException(const char* message) : message_(message) 
    {
        cout << "MyException ..." << endl;
    }
    MyException(const MyException& other) : message_(other.message_)
    {
        cout << "Copy MyException ..." << endl;
    }
    ~MyException() 
    {
        cout << "~MyException ..." << endl;
    }
    const char* What() const
    {
        return message_.c_str();
    }
private:
    string message_;
};
double Devide(double a, double b)
{
    if (b == 0.0)
    {
        MyException e("devision by zero .");
        throw e;                        //调用拷贝构造函数
    }
    else
        return a / b;
}
void MyTerminate()
{
    cout << "MyTerminate" << endl;
    exit(-1);
}
int main(void)
{
    set_terminate(MyTerminate);
    try
    {
        try
        {
            cout << Devide(5.0, 0.0) << endl;
        }
        catch (int)
        {
            cout << "Inner Catch ..." << endl;
        }

    }
    catch (int)
    {
        cout << "Outer Catch ..." << endl;
    }
}

栈展开

• 沿着嵌套调用链接向上查找，直至为异常找到一个catch子句。这个过程称之为栈展开
  
  • 为局部对象调用析构函数
  • 析构函数应该从不抛出异常
    
    • 栈展开期间会执行析构函数，在执行析构函数的时候，已经引发的异常但还没处理，如果这个过程中析构函数有抛出新的异常，将会调用标准库的terminate函数
  • 异常与构造函数
    
    • 构造函数中可以抛出异常。如果在构造函数中抛出异常，则可能该对象只是部分被构造。及时对象只是被部分构造，也要保证销毁已构造的成员。