C++异常机制

本文中的一些重要概念摘自C语言中文网。
链接：http://c.biancheng.net/cplus/exception/

程序运行时常会碰到一些错误，例如除数为 0、数组下标越界等，这些错误如果不能发现并加以处理，很可能会导致程序崩溃。

C++ 异常处理机制就可以让我们捕获并处理这些错误，然后我们可以让程序沿着一条不会出错的路径继续执行，或者不得不结束程序，但在结束前可以做一些必要的工作，
如：
1.将内存中的数据写入文件
2.关闭打开的文件
3.释放分配的内存

C++ 异常处理机制会涉及 try、catch、throw 三个关键字。

在具体学习异常之前，我们先来了解一下在程序会遇到的三种错误：
1.语法错误：只有符合语法规范的程序才能通过编译，一般编译器会帮我们指出，所以这种错误是最不需要程序员操心的错误了
2.业务逻辑错误：这种错误可以通过运行调试，或者输入一些数据测试，通过修改完善错误逻辑从而得到解决
3.运行时错误:程序在运行期间发生的错误，例如除数为 0、内存分配失败、数组越界、文件不存在等。C++ 异常（Exception）机制就是为解决运行时错误而引入的。

运行时错误如果放任不管，系统就会执行默认的操作，终止程序运行，也就是我们常说的程序崩溃（Crash）。C++ 提供了异常（Exception）机制，让我们能够捕获运行时错误，给程序一次“起死回生”的机会，或者至少告诉用户发生了什么再终止程序。

捕获异常
我们可以借助 C++ 异常机制来捕获上面的异常，避免程序崩溃。捕获异常的语法为：
try{
// 可能抛出异常的语句
}catch(exceptionType variable){
// 处理异常的语句
}

try和catch都是 C++ 中的关键字，后跟语句块，不能省略{ }。try 中包含可能会抛出异常的语句，一旦有异常抛出就会被后面的 catch 捕获。从 try 的意思可以看出，它只是“检测”语句块有没有异常，如果没有发生异常，它就“检测”不到。catch 是“抓住”的意思，用来捕获并处理 try 检测到的异常；如果 try 语句块没有检测到异常（没有异常抛出），那么就不会执行 catch 中的语句。

这就好比，catch 告诉 try：你去检测一下程序有没有错误，有错误的话就告诉我，我来处理，没有的话就不要找我。

catch语句后面的exceptionType很显然就是异常的类型。

接下来我们先来看一个例子：

#include<iostream>
#include<string>
#include<exception>

using namespace std;

int main()
{
    string s1("I am a boy!");
    try
    {
        char c1 = s1[20];  
        cout << c1 << endl;
    }
    catch(exception e)
    {
        cout << "the c1 out of bound" << endl;
    }

    try
    {
        char c2 = s1.at(20);
        cout << c2 << endl;
    }
    catch(const std::exception& e)
    {
        std::cerr << e.what() << '\n';
    }

    return 0;
}

程序运行结果：

从程序的运行结果可以看出，第一个采用[]运算符的内存越界异常没有捕获到，这是因为在使用[]运算符的时候不会进行越界检查。而使用at()成员函数的时候是会进行越界检查的。

换句话说，发生异常时必须将异常明确地抛出，try 才能检测到；如果不抛出来，即使有异常 try 也检测不到。所谓抛出异常，就是明确地告诉程序发生了什么错误。

异常一旦抛出，会立刻被 try 检测到，并且不会再执行异常点（异常发生位置）后面的语句。所以c2字符输出的那段代码并没有执行，而是直接跳到了catch语句中的标准错误输出。即使 catch 语句成功地处理了错误，程序的执行流也不会再回退到异常点，所以这些语句永远都没有执行的机会了，准确的说，就是这些代码被跳过了。

执行完 catch 块所包含的代码后，程序会继续执行 catch 块后面的代码，就恢复了正常的执行流。

异常处理流程：
抛出（Throw）--> 检测（Try） --> 捕获（Catch）

发生异常的位置
异常可以发生在当前的 try 块中，也可以发生在 try 块所调用的某个函数中，或者是所调用的函数又调用了另外的一个函数，这个另外的函数中发生了异常。这些异常，都可以被 try 检测到。

发生异常后，程序的执行流会沿着函数的调用链往前回退，直到遇见 try 才停止。在这个回退过程中，调用链中剩下的代码（所有函数中未被执行的代码）都会被跳过，没有执行的机会了。

异常类型：
try{
// 可能抛出异常的语句
}catch(exceptionType variable){
// 处理异常的语句
}

exceptionType是异常类型，它指明了当前的 catch 可以处理什么类型的异常；variable是一个变量，用来接收异常信息。当程序抛出异常时，会创建一份数据，这份数据包含了错误信息，程序员可以根据这些信息来判断到底出了什么问题，接下来怎么处理。

C++ 规定，异常类型可以是 int、char、float、bool 等基本类型，也可以是指针、数组、字符串、结构体、类等聚合类型。C++ 语言本身以及标准库中的函数抛出的异常，都是 exception 类或其子类的异常。也就是说，抛出异常时，会创建一个** exception 类或其子类的对象**。

exceptionType 类型匹配的异常数据才会被传递给 variable，否则 catch 不会接收这份异常数据，也不会执行 catch 块中的语句。

我们可以将 catch 看做一个没有返回值的函数，当异常发生后 catch 会被调用，并且会接收实参（异常数据）。

总起来说，catch 和真正的函数调用相比，多了一个「在运行阶段将实参和形参匹配」的过程。

另外需要注意的是，如果不希望 catch 处理异常数据，也可以将 variable 省略掉，也即写作：
try{
// 可能抛出异常的语句
}catch(exceptionType){
// 处理异常的语句
}

这样只会将异常类型和 catch 所能处理的类型进行匹配，不会传递异常数据了。

多级 catch
前面的例子中，一个 try 对应一个 catch，这只是最简单的形式。其实，一个 try 后面可以跟多个 catch：
try{
//可能抛出异常的语句
}catch (exception_type_1 e){
//处理异常的语句
}catch (exception_type_2 e){
//处理异常的语句
}
//其他的catch
catch (exception_type_n e){
//处理异常的语句
}
当异常发生时，程序会按照从上到下的顺序，将异常类型和 catch 所能接收的类型逐个匹配。一旦找到类型匹配的 catch 就停止检索，并将异常交给当前的 catch 处理（其他的 catch 不会被执行）。如果最终也没有找到匹配的 catch，就只能交给系统处理，终止程序的运行。

catch 在匹配过程中的类型转换
C/C++ 中存在多种多样的类型转换，以普通函数（非模板函数）为例，发生函数调用时，如果实参和形参的类型不是严格匹配，那么会将实参的类型进行适当的转换，以适应形参的类型，这些转换包括：
1.算数转换：例如 int 转换为 float，char 转换为 int，double 转换为 int 等。
2.向上转型：也就是派生类向基类的转换。
3.const 转换：也即将非 const 类型转换为 const 类型，例如将 char * 转换为 const char *。
4.数组或函数指针转换：如果函数形参不是引用类型，那么数组名会转换为数组指针，函数名也会转换为函数指针。
5.用户自定的类型转换。

catch 在匹配异常类型的过程中，也会进行类型转换，但是这种转换受到了更多的限制，仅能进行「向上转型」、「const 转换」和「数组或函数指针转换」，其他的都不能应用于 catch。

*throw关键字
在 C++ 中，我们使用 throw 关键字来显式地抛出异常，它的用法为：
throw exceptionData;
exceptionData 是“异常数据”的意思，它可以包含任意的信息，完全有程序员决定。exceptionData 可以是 int、float、bool 等基本类型，也可以是指针、数组、字符串、结构体、类等聚合类型，请看下面的例子：
char str[] = "http://c.biancheng.net";
char *pstr = str;
class Base{};
Base obj;
throw 100; //int 类型
throw str; //数组类型
throw pstr; //指针类型
throw obj; //对象类型

throw 用作异常规范
throw 关键字除了可以用在函数体中抛出异常，还可以用在函数头和函数体之间，指明当前函数能够抛出的异常类型，这称为异常规范（Exception specification），有些地方也称为异常指示符或异常列表。

例子：
double func (char param) throw (int);

这条语句声明了一个名为 func 的函数，它的返回值类型为 double，有一个 char 类型的参数，并且只能抛出 int 类型的异常。如果抛出其他类型的异常，try 将无法捕获，只能终止程序。

如果函数会抛出多种类型的异常，那么可以用逗号隔开：
double func (char param) throw (int, char, exception);

如果函数不会抛出任何异常，那么( )中什么也不写：
double func (char param) throw ();

如此，func() 函数就不能抛出任何类型的异常了，即使抛出了，try 也检测不到。

1) 虚函数中的异常规范
C++ 规定，派生类虚函数的异常规范必须与基类虚函数的异常规范一样严格，或者更严格。只有这样，当通过基类指针（或者引用）调用派生类虚函数时，才能保证不违背基类成员函数的异常规范。请看下面的例子：
class Base{
public:
virtual int fun1(int) throw();
virtual int fun2(int) throw(int);
virtual string fun3() throw(int, string);
};
class Derived:public Base{
public:
int fun1(int) throw(int); //错！异常规范不如 throw() 严格
int fun2(int) throw(int); //对！有相同的异常规范
string fun3() throw(string); //对！异常规范比 throw(int,string) 更严格
}
派生类的异常规范要比基类更严格，也就是说基类表明不抛出的异常，派生类一定要遵守，或者做的更严格。

2) 异常规范与函数定义和函数声明
C++ 规定，异常规范在函数声明和函数定义中必须同时指明，并且要严格保持一致，不能更加严格或者更加宽松。

请看下面的几组函数：
//错！定义中有异常规范，声明中没有
void func1();
void func1() throw(int) { }
//错！定义和声明中的异常规范不一致
void func2() throw(int);
void func2() throw(int, bool) { }
//对！定义和声明中的异常规范严格一致
void func3() throw(float, char);
void func3() throw(float, char) { }

请抛弃异常规范，不要再使用它
异常规范的初衷是好的，它希望让程序员看到函数的定义或声明后，立马就知道该函数会抛出什么类型的异常，这样程序员就可以使用 try-catch 来捕获了。如果没有异常规范，程序员必须阅读函数源码才能知道函数会抛出什么异常。

不过这有时候也不容易做到。例如，func_outer() 函数可能不会引发异常，但它调用了另外一个函数 func_inner()，这个函数可能会引发异常。再如，您编写的函数调用了老式的库函数，此时不会引发异常，但是库更新以后这个函数却引发了异常。总之，异常规范的初衷实现起来有点困难，所以大家达成的一致意见是，最好不要使用异常规范。

异常规范是 C++98 新增的一项功能，但是后来的 C++11 已经将它抛弃了，不再建议使用。