C++的异常处理
1、什么是异常处理
2、为何须要异常处理，以及异常处理的基本思想
C++之父Bjarne Stroustrup在《The C++ Programming Language》中讲到：一个库的做者能够检测出发生了运行时错误，但通常不知道怎样去处理它们（由于和用户具体的应用有关）；另外一方面，库的用户知道怎样处理这些错误，但却没法检查它们什么时候发生（若是能检测，就能够再用户的代码里处理了，不用留给库去发现）。java
Bjarne Stroustrup说：提供异常的基本目的就是为了处理上面的问题。基本思想是：让一个函数在发现了本身没法处理的错误时抛出（throw）一个异常，而后它的（直接或者间接）调用者可以处理这个问题。
The fundamental idea is that a function that finds a problem it cannot cope with throws an exception, hoping that its (direct or indirect) caller can handle the problem.python
也就是《C++ primer》中说的：将问题检测和问题处理相分离。
Exceptions let us separate problem detection from problem resolutionios
一种思想：在全部支持异常处理的编程语言中（例如java），要认识到的一个思想：在异常处理过程当中，由问题检测代码能够抛出一个对象给问题处理代码，经过这个对象的类型和内容，实际上完成了两个部分的通讯，通讯的内容是“出现了什么错误”。固然，各类语言对异常的具体实现有着或多或少的区别，可是这个通讯的思想是不变的。程序员
3、异常出现以前处理错误的方式
在C语言的世界中，对错误的处理老是围绕着两种方法：一是使用整型的返回值标识错误；二是使用errno宏（能够简单的理解为一个全局整型变量）去记录错误。固然C++中仍然是能够用这两种方法的。编程
这两种方法最大的缺陷就是会出现不一致问题。例若有些函数返回1表示成功，返回0表示出错；而有些函数返回0表示成功，返回非0表示出错。数组
还有一个缺点就是函数的返回值只有一个，你经过函数的返回值表示错误代码，那么函数就不能返回其余的值。固然，你也能够经过指针或者C++的引用来返回另外的值，可是这样可能会令你的程序略微晦涩难懂。dom
4、异常为何好
在若是使用异常处理的优势有如下几点：eclipse
1. 函数的返回值能够忽略，但异常不可忽略。若是程序出现异常，可是没有被捕获，程序就会终止，这多少会促使程序员开发出来的程序更健壮一点。而若是使用C语言的error宏或者函数返回值，调用者都有可能忘记检查，从而没有对错误进行处理，结果形成程序莫名其面的终止或出现错误的结果。编程语言
2. 整型返回值没有任何语义信息。而异常却包含语义信息，有时你从类名就可以体现出来。ide
3. 整型返回值缺少相关的上下文信息。异常做为一个类，能够拥有本身的成员，这些成员就能够传递足够的信息。
4. 异常处理能够在调用跳级。这是一个代码编写时的问题：假设在有多个函数的调用栈中出现了某个错误，使用整型返回码要求你在每一级函数中都要进行处理。而使用异常处理的栈展开机制，只须要在一处进行处理就能够了，不须要每级函数都处理。
5、C++中使用异常时应注意的问题
任何事情都是两面性的，异常有好处就有坏处。若是你是C++程序员，而且但愿在你的代码中使用异常，那么下面的问题是你要注意的。
1. 性能问题。这个通常不会成为瓶颈，可是若是你编写的是高性能或者实时性要求比较强的软件，就须要考虑了。
（若是你像我同样，曾经是java程序员，那么下面的事情可能会让你一时迷糊，可是没办法，谁叫你如今学的是C++呢。）
2. 指针和动态分配致使的内存回收问题：在C++中，不会自动回收动态分配的内存，若是遇到异常就须要考虑是否正确的回收了内存。在java中，就基本不须要考虑这个，有垃圾回收机制真好！
3. 函数的异常抛出列表：java中是若是一个函数没有在异常抛出列表中显式指定要抛出的异常，就不容许抛出；但是在C++中是若是你没有在函数的异常抛出列表指定要抛出的异常，意味着你能够抛出任何异常。
4. C++中编译时不会检查函数的异常抛出列表。这意味着你在编写C++程序时，若是在函数中抛出了没有在异常抛出列表中声明的异常，编译时是不会报错的。而在java中，eclipse的提示功能真的好强大啊！
5. 在java中，抛出的异常都要是一个异常类；可是在C++中，你能够抛出任何类型，你甚至能够抛出一个整型。（固然，在C++中若是你catch中接收时使用的是对象，而不是引用的话，那么你抛出的对象必需要是可以复制的。这是语言的要求，不是异常处理的要求）。
6. 在C++中是没有finally关键字的。而java和python中都是有finally关键字的。
6、异常的基本语法
1. 抛出和捕获异常
很简单，抛出异经常使用throw，捕获用try……catch。
捕获异常时的注意事项：
1. catch子句中的异常说明符必须是彻底类型，不能够为前置声明，由于你的异常处理中经常要访问异常类的成员。例外：只有你的catch子句使用指针或者引用接收参数，而且在catch子句内你不访问异常类的成员，那么你的catch子句的异常说明符才能够是前置声明的类型。
2. catch的匹配过程是找最早匹配的，不是最佳匹配。
3. catch的匹配过程当中，对类型的要求比较严格。不容许标准算术转换和类类型的转换。（类类型的转化包括两种：经过构造函数的隐式类型转化和经过转化操做符的类型转化）。
4. 和函数参数相同的地方有：
① 若是catch中使用基类对象接收子类对象，那么会形成子类对象分隔（slice）为父类子对象（经过调用父类的复制构造函数）；
② 若是catch中使用基类对象的引用接受子类对象，那么对虚成员的访问时，会发生动态绑定，即会多态调用。
③ 若是catch中使用基类对象的指针，那么必定要保证throw语句也要抛出指针类型，而且该指针所指向的对象，在catch语句执行是还存在（一般是动态分配的对象指针）。
5. 和函数参数不一样的地方有：
① 若是throw中抛出一个对象，那么不管是catch中使用什么接收（基类对象、引用、指针或者子类对象、引用、指针），在传递到catch以前，编译器都会另外构造一个对象的副本。也就是说，若是你以一个throw语句中抛出一个对象类型，在catch处经过也是经过一个对象接收，那么该对象经历了两次复制，即调用了两次复制构造函数。一次是在throw时，将“抛出到对象”复制到一个“临时对象”（这一步是必须的），而后是由于catch处使用对象接收，那么须要再从“临时对象”复制到“catch的形参变量”中； 若是你在catch中使用“引用”来接收参数，那么不须要第二次复制，即形参的引用指向临时变量。
② 该对象的类型与throw语句中体现的静态类型相同。也就是说，若是你在throw语句中抛出一个指向子类对象的父类引用，那么会发生分割现象，即只有子类对象中的父类部分会被抛出，抛出对象的类型也是父类类型。（从实现上讲，是由于复制到“临时对象”的时候，使用的是throw语句中类型的（这里是父类的）复制构造函数）。
③ 不能够进行标准算术转换和类的自定义转换：在函数参数匹配的过程当中，能够进行不少的类型转换。可是在异常匹配的过程当中，转换的规则要严厉。
④ 异常处理机制的匹配过程是寻找最早匹配（first fit），函数调用的过程是寻找最佳匹配（best fit）。
2. 异常类型
上面已经提到过，在C++中，你能够抛出任何类型的异常。（哎，居然能够抛出任何类型，刚看到到这个的时候，我半天没反应过来，由于java中这样是不行的啊）。
注意：也是上面提到过的，在C++中若是你throw语句中抛出一个对象，那么你抛出的对象必需要是可以复制的。由于要进行复制副本传递，这是语言的要求，不是异常处理的要求。（在上面“和函数参数不一样的地方”中也讲到了，由于是要复制先到一个临时变量中）
3. 栈展开
栈展开指的是：当异常抛出后，匹配catch的过程。
抛出异常时，将暂停当前函数的执行，开始查找匹配的catch子句。沿着函数的嵌套调用链向上查找，直到找到一个匹配的catch子句，或者找不到匹配的catch子句。
注意事项：
1. 在栈展开期间，会销毁局部对象。
① 若是局部对象是类对象，那么经过调用它的析构函数销毁。
② 可是对于经过动态分配获得的对象，编译器不会自动删除，因此咱们必须手动显式删除。（这个问题是如此的常见和重要，以致于会用到一种叫作RAII的方法，详情见下面讲述）
2. 析构函数应该从不抛出异常。若是析构函数中须要执行可能会抛出异常的代码，那么就应该在析构函数内部将这个异常进行处理，而不是将异常抛出去。
缘由：在为某个异常进行栈展开时，析构函数若是又抛出本身的未经处理的另外一个异常，将会致使调用标准库 terminate 函数。而默认的terminate 函数将调用 abort 函数，强制从整个程序非正常退出。
3. 构造函数中能够抛出异常。可是要注意到：若是构造函数由于异常而退出，那么该类的析构函数就得不到执行。因此要手动销毁在异常抛出前已经构造的部分。
4. 异常从新抛出
语法：使用一个空的throw语句。即写成： throw;
注意问题：
① throw; 语句出现的位置，只能是catch子句中或者是catch子句调用的函数中。
② 从新抛出的是原来的异常对象，即上面提到的“临时变量”，不是catch形参。
③ 若是但愿在从新抛出以前修改异常对象，那么应该在catch中使用引用参数。若是使用对象接收的话，那么修改异常对象之后，不能经过“从新抛出”来传播修改的异常对象，由于从新抛出不是catch形参，应该使用的是 throw e; 这里“e”为catch语句中接收的对象参数。
5. 捕获全部异常（匹配任何异常）
语法：在catch语句中，使用三个点（…）。即写成：catch (…) 这里三个点是“通配符”，相似 可变长形式参数。
常见用法：与“从新抛出”表达式一块儿使用，在catch中完成部分工做，而后从新抛出异常。
6. 未捕获的异常
意思是说，若是程序中有抛出异常的地方，那么就必定要对其进行捕获处理。不然，若是程序执行过程当中抛出了一个异常，而又没有找到相应的catch语句，那么会和“栈展开过程当中析构函数抛出异常”同样，会 调用terminate 函数，而默认的terminate 函数将调用 abort 函数，强制从整个程序非正常退出。
7. 构造函数的函数测试块
对于在构造函数的初始化列表中抛出的异常，必须使用函数测试块（function try block）来进行捕捉。语法类型下面的形式：
MyClass::MyClass(int i) try :member(i) { //函数体 } catch(异常参数) { //异常处理代码 }
注意事项：在函数测试块中捕获的异常，在catch语句中能够执行一个内存释放操做，而后异常仍然会再次抛出到用户代码中。
8. 异常抛出列表（异常说明 exception specification）
就是在函数的形参表以后（若是是const成员函数，那么在const以后），使用关键字throw声明一个带着括号的、可能为空的 异常类型列表。形如：throw () 或者 throw (runtime_error, bad_alloc) 。
含义：表示该函数只能抛出 在列表中的异常类型。例如：throw() 表示不抛出任何异常。而throw (runtime_error, bad_alloc)表示只能抛出runtime_error 或bad_alloc两种异常。
注意事项：（之前学java的尤为要注意，和java中不太同样）
① 若是函数没有显式的声明 抛出列表，表示异常能够抛出任意列表。（在java中，若是没有异常抛出列表，那么是不能抛出任何异常的）。
② C++的 “throw()”至关于java的不声明抛出列表。都表示不抛出任何异常。
③ 在C++中，编译的时候，编译器不会对异常抛出列表进行检查。也就是说，若是你声明了抛出列表，即便你的函数代码中抛出了没有在抛出列表中指定的异常，你的程序依然能够经过编译，到运行时才会出错，对于这样的异常，在C++中称为“意外异常”（unexpeced exception）。（这点和java又不相同，在java中，是要进行严格的检查的）。
意外异常的处理：
若是程序中出现了意外异常，那么程序就会调用函数unexpected()。这个函数的默认实现是调用terminate函数，即默认最终会终止程序。
虚函数重载方法时异常抛出列表的限制：
在子类中重载时，函数的异常说明 必需要比父类中要一样严格，或者更严格。换句话说，在子类中相应函数的异常说明不能增长新的异常。或者再换句话说：父类中异常抛出列表是该虚函数的子类重载版本能够抛出异常列表的 超集。
函数指针中异常抛出列表的限制：
异常抛出列表是函数类型的一部分，在函数指针中也能够指定异常抛出列表。可是在函数指针初始化或者赋值时，除了要检查返回值和形式参数外，还要注意异常抛出列表的限制：源指针的异常说明必须至少和目标指针的同样严格。比较拗口，换句话说，就是声明函数指针时指定的异常抛出列表，必定要实际函数的异常抛出列表的超集。 若是定义函数指针时不提供异常抛出列表，那么能够指向可以抛出任意类型异常的函数。
抛出列表是否有用：
在《More effective C++》第14条，Scott Meyers指出“要谨慎的使用异常说明”（Use exception specifications judiciously）。“异常说明”，就是咱们全部的“异常抛出列表”。之因此要谨慎，根本缘由是由于C++编译器不会检查异常抛出列表，这样就可能在函数代码中、或者调用的函数中抛出了没有在抛出列表中指定的异常，从而致使程序调用unexpected函数，形成程序提早终止。同时他给出了三条要考虑的事情：
① 在模板中不要使用异常抛出列表。（缘由很简单，连用来实例模板的类型都不知道，也就没法肯定该函数是否应该抛出异常，抛出什么异常）。
② 若是A函数内调用了B函数，而B函数没有声明异常抛出列表，那么A函数自己也不该该设定异常抛出列表。（缘由是，B函数可能抛出没有在A函数的异常抛出列表中声明的异常，会致使调用unex函数）；
③ 经过set_unexpected函数指定一个新的unexpected函数，在该函数中捕获异常，并抛出一个统一类型的异常。
另外，在《C++ Primer》4th 中指出，虽然异常说明应用有限，可是若是可以肯定该函数不会抛出异常，那么显式声明其不抛出任何异常 有好处。经过语句："throw ()"。这样的好处是：对于程序员，当调用这样的函数时，不须要担忧异常。对于编译器，能够执行被可能抛出异常所抑制的优化。
7、标准库中的异常类
All exceptions thrown from the language or the library are derived from the base class exception. This class is the root of several standard exception classes that form a hierarchy, as shown in Figure 3.1. These standard exception classes can be divided into three groups:（引自《C++ Standard Library》）
每一个类所在的头文件在图下方标识出来.
标准异常类的成员：
① 在上述继承体系中，每一个类都有提供了构造函数、复制构造函数、和赋值操做符重载。
② logic_error类及其子类、runtime_error类及其子类，它们的构造函数是接受一个string类型的形式参数，用于异常信息的描述；
③ 全部的异常类都有一个what()方法，返回const char* 类型（C风格字符串）的值，描述异常信息。
| 异常名称 |
描述 |
| exception | 全部标准异常类的父类 |
| bad_alloc | 当operator new and operator new[]，请求分配内存失败时 |
| bad_exception | 这是个特殊的异常，若是函数的异常抛出列表里声明了bad_exception异常，当函数内部抛出了异常抛出列表中没有的异常，这是调用的unexpected函数中若抛出异常，不论什么类型，都会被替换为bad_exception类型 |
| bad_typeid | 使用typeid操做符，操做一个NULL指针，而该指针是带有虚函数的类，这时抛出bad_typeid异常 |
| bad_cast | 使用dynamic_cast转换引用失败的时候 |
| ios_base::failure | io操做过程出现错误 |
| logic_error | 逻辑错误，能够在运行前检测的错误 |
| runtime_error | 运行时错误，仅在运行时才能够检测的错误 |
logic_error的子类：
| 异常名称 |
描述 |
| length_error | 试图生成一个超出该类型最大长度的对象时，例如vector的resize操做 |
| domain_error | 参数的值域错误，主要用在数学函数中。例如使用一个负值调用只能操做非负数的函数 |
| out_of_range | 超出有效范围 |
| invalid_argument | 参数不合适。在标准库中，当利用string对象构造bitset时，而string中的字符不是’0’或’1’的时候，抛出该异常 |
runtime_error的子类：
| 异常名称 |
描述 |
| range_error | 计算结果超出了有意义的值域范围 |
| overflow_error | 算术计算上溢 |
| underflow_error | 算术计算下溢 |
8、编写本身的异常类
1. 为何要编写本身的异常类？
① 标准库中的异常是有限的；
② 在本身的异常类中，能够添加本身的信息。（标准库中的异常类值容许设置一个用来描述异常的字符串）。
2. 如何编写本身的异常类？
① 建议本身的异常类要继承标准异常类。由于C++中能够抛出任何类型的异常，因此咱们的异常类能够不继承自标准异常，可是这样可能会致使程序混乱，尤为是当咱们多人协同开发时。
② 当继承标准异常类时，应该重载父类的what函数和虚析构函数。
③ 由于栈展开的过程当中，要复制异常类型，那么要根据你在类中添加的成员考虑是否提供本身的复制构造函数。
9、用类来封装资源分配和释放
为何要使用类来封装资源分配和释放？
为了防止内存泄露。由于在函数中发生异常，那么对于动态分配的资源，就不会自动释放，必需要手动显式释放，不然就会内存泄露。而对于类对象，会自动调用其析构函数。若是咱们在析构函数中显式delete这些资源，就能保证这些动态分配的资源会被释放。
如何编写这样的类？
将资源的分配和销毁用类封转起来。在析构函数中要显式的释放（delete或delete[]）这些资源。这样，若用户代码中发生异常，看成用域结束时，会调用给该类的析构函数释放资源。这种技术被称为：资源分配即初始化。（resource allocation is initialization，缩写为"RAII"）。
10、auto_ptr的使用（很是重要）
“用类封装资源的分配和释放”是如此的重要，C++标准库为咱们提供了一个模板类来实现这个功能。名称为auto_ptr，在memory头文件中。
| 函数 |
功能 |
| auto_ptr <T> ap() | 默认构造函数，建立名为ap的未绑定的auto_ptr对象 |
| auto_ptr<T> ap(p); | 建立名为 ap 的 auto_ptr 对象，ap 拥有指针 p 指向的对象。该构造函数为 explicit |
| auto_ptr<T> ap1(ap2); | 建立名为 ap1 的 auto_ptr 对象，ap1 保存原来存储在 ap2 中的指针。将全部权转给 ap1，ap2 成为未绑定的 auto_ptr 对象 |
| ap1 = ap2 | 将全部权 ap2 转给 ap1。删除 ap1 指向的对象而且使 ap1 指向 ap2 指向的对象，使 ap2 成为未绑定的 |
| ~ap | 析构函数。删除 ap 指向的对象 |
| *ap | 返回对 ap 所绑定的对象的引用 |
| ap-> | 返回 ap 保存的指针 |
| ap.reset(p) | 若是 p 与 ap 的值不一样，则删除 ap 指向的对象而且将 ap 绑定到 p |
| ap.release() | 返回 ap 所保存的指针而且使 ap 成为未绑定的 |
| ap.get() | 返回 ap 保存的指针 |
auto_ptr类的使用：
1. 用来保存一个指向对象类型的指针。注意必须是动态分配的对象（即便用new非配的）的指针。既不能是动态分配的数组（使用new []）指针，也不能是非动态分配的对象指针。
2. 惯用的初始化方法：在用户代码中，使用new表达式做为auto_ptr构造函数的参数。（注意：auto_ptr类接受指针参数的构造函数为explicit，因此必须显式的进行初始化）。
3. auto_ptr的行为特征：相似普通指针行为。auto_ptr存在的主要缘由就是，为了防止动态分配的对象指针形成的内存泄露，既然是指针，其具备"*"操做符和"->"操做符。因此auto_ptr的主要目的就是：首先保证自动删除auto_ptr所引用的对象，而且要支持普通指针行为。
4. auto_ptr对象的复制和赋值是有破坏性的。① 会致使右操做数成为未绑定的，致使auto_ptr对象不能放到容器中；② 在赋值的时候，将有操做符修改成未绑定，即修改了右操做数，因此要保证这里的赋值操做符右操做数是能够修改的左值（然而普通的赋值操做符中，右操做数能够不是左值）；③和普通的赋值操做符同样，若是是自我赋值，那么没有效果；④ 致使auto_ptr对象不能放到容器中。
5. 若是auto_ptr初始化的时候，使用默认构造函数，成为未绑定的auto_ptr对象，那么能够经过reset操做将其绑定到一个对象。
6. 若是但愿测试auto_ptr是否已经绑定到了一个对象，那么使用get()函数的返回值与NULL进行比较。
auto_ptr的缺陷：
1. 不能使用auto_ptr对象保存指向静态分配的对象的指针，也不能保存指向动态分配的数组的指针。
2. 不能讲两个auto_ptr对象指向同一个对象。由于在一个auto_ptr对象析构之后，形成另外一个auto_ptr对象指向了已经释放的内存。形成这种状况的两种主要常见缘由是：① 用同一个指针来初始化或者reset两个不一样的auto_ptr对象；② 使用一个auto_ptr对象的get函数返回值去初始化或者reset另外一个auto_ptr对象。
3. 不能将auto_ptr对象放到容器中。由于其复制和赋值操做具备破坏性。
11、常见的异常处理问题
动态内存分配错误
① 分配动态内存使用的是new和new[]操做符，若是他们分配内存失败，就会抛出bad_alloc异常，在new头文件中，因此咱们的代码中应该捕捉这些异常。常见的代码形式以下：
- try {
- //其余代码
- ptr = new int[num_max];
- //其余代码
- } catch(bad_alloc &e) {
- //这里常见的处理方式为：先释放已经分配的内存，而后结束程序，或者打印一条错误信息并继续执行
- }
② 可使用相似C语言的方式处理，但这时要使用的nothrow版本，使用"new (nothrow)"的形式分配内存。这时，若是分配不成功，返回的是NULL指针，而再也不是抛出bad_alloc异常。
③ 能够定制内存分配失败行为。C++容许指定一个new 处理程序（newhandler）回调函数。默认的并无new 处理程序，若是咱们设置了new 处理程序，那么当new和new[] 分配内存失败时，会调用咱们设定的new 处理程序，而不是直接抛出异常。经过set_new_handler函数来设置该回调函数。要求被回调的函数没有返回值，也没有形式参数。
12、来自C++之父Bjarne Stroustrup的建议
节选自《The C++ Programming Language》 ——C++之父Bjarne Stroustrup
1. Don’t use exceptions where more local control structures will suffice; 当局部的控制可以处理时，不要使用异常；
2. Use the "resource allocation is initialization" technique to manage resources; 使用“资源分配即初始化”技术去管理资源；
3. Minimize the use of try-blocks. Use "resource acquisition is initialization" instead of explicit handler code; 尽可能少用try-catch语句块，而是使用“资源分配即初始化”技术。
4. Throw an exception to indicate failure in a constructor; 若是构造函数内发生错误，经过抛出异常来指明。
5. Avoid throwing exceptions from destructors; 避免在析构函数中抛出异常。
6. Keep ordinary code and error-handling code separate; 保持普通程序代码和异常处理代码分开。
7. Beware of memory leaks caused by memory allocated by new not being released in case of an exception; 当心经过new分配的内存在发生异常时，可能形成内存泄露。
8. Assume that every exception that can be thrown by a function will be thrown; 若是一个函数可能抛出某种异常，那么咱们调用它时，就要假定它必定会抛出该异常，即要进行处理。
9. Don't assume that every exception is derived from class exception; 要记住，不是全部的异常都继承自exception类。 10. A library shouldn't unilaterally terminate a program. Instead, throw an exception and let a caller decide; 编写的供别人调用的程序库，不该该结束程序，而应该经过抛出异常，让调用者决定如何处理（由于调用者必需要处理抛出的异常）。 11. Develop an error-handling strategy early in a design; 若开发一个项目，那么在设计阶段就要肯定“错误处理的策略”。
-
每一个你不满意的现在，都有一个你没有努力的曾经。