转自：https://blog.csdn.net/sky453589103/article/details/49862949
异常是指程序在运行时存在异常行为，这些异常的行为让函数不能正常执行。异常应该捕获的应该是你能够处理的错误，比如：不能连接服务器，不能连接数据库等，但异常不应该是你修复代码的bug的手段，比如：数组访问越界。死锁等情况。在异常处理中，你需要的做的是尽可能的修补你错误，比如：释放内存。解锁互斥量。
c++的异常包括下面的三个部分：
1. throw子句：throw 子句用于抛出异常，被抛出的异常可以是C++的内置类型（例如： throw int(1);），也可以是自定义类型。
2. catch子句：每个catch子句都代表着一种异常的处理。catch子句用于处理特定类型的异常。
3. try区段：这个区段中包含了可能发生异常的代码，在发生了异常之后，需要通过throw抛出。
编写异常：
通常的形式是：
try {
// do something
throw exception;
} catch (exception declaration) {
// excepetion handling code
// throw or no
} catch (exception declaration) {
// another excepetion handling code
// throw or no
}
示例：
// 定义自己的异常类，public 继承C++标准库的exception
class myexception : public std::exception {
public :
myexception(std::string s) : exception(s.c_str()) {
}
virtual const char *what() const {
return exception::what();
}
};
void Func() {
try{
int *p = NULL;
if (p == NULL) {
throw myexception("p is NULL");
}
}
catch(myexception e) {
printf("%s\n", e.what());
throw; //重新抛出异常，异常类型为myexception
}
catch (std::exception e) {
printf("%s", e.what());
}
}
在try的语句块内声明的变量在外部是不可以访问的，即使是在catch子句内也不可以访问。
寻找异常处理（exception handling）代码：
当一个exception被抛出的时候，控制权会从函数调用中释放出来，并需找一个可以处理的catch子句。对于一个抛出异常的try区段，程序会先检查与该try区段关联的catch子句，如果找到了匹配的catch子句，就使用这个catch子句处理这个异常。
否则，如果这个try区段嵌套在其他try区段中，则继续检查与外层try匹配的catch子句。如果仍然没有找到匹配的catch子句，则退出当前这个主调函数，并在调用了刚刚退出的这个函数的其他函数中寻找。这个过程就是所谓的
栈展开，栈展开会沿着嵌套函数的调用链不断查找，知道找到了已抛出的异常匹配的catch子句。如果在
最后还是没有找到对应的catch子句的话，则退出主函数后查找过程终止，程序调用标准函数库的terminate()函数，终止该程序的执行。
catch子句的查找：
catch子句是
按照出现的顺序进行匹配的（以上面的代码为例，异常先会匹配catch(myexception e)子句，然后在匹配
catch (std::exception e)子句，一步一步的栈展开）。在寻找catch子句的过程中，抛出的异常可以进行
类型转换，但是比较严格：
1. 允许从非常量转换到常量的类型转换。
2. 允许从派生类到基类的转换。
3. 允许数组被转换成为指向数组（元素）类型的指针，函数被转换成指向该函数类型的指针。
4. 标准算术类型的转换（比如：把bool型和char型转换成int型）和类类型转换(使用类的类型转换运算符和转换构造函数)。
如果你想一次性
捕获全部的异常的话，C++也提供了一种简便的做法，在catch子句的异常声明中使用
省略号来作为异常声明：
void Func() {
try {
// your code
}
catch(...) {
// special operation for handling exception
throw;
}
}
决定一个throw是否发生在发生在try区段中，我们修改一下上面的例子，新增两个类A和类B ：
class myexception : public std::exception {
public :
myexception(std::string s) : exception(s.c_str()) {
}
virtual const char *what() const {
return exception::what();
}
};
class A {
public :
~A() {
printf("A's destructor\n");
}
};
class B {
public :
~B() {
printf("B's destructor\n");
}
};
void Func() {
A a;
throw myexception("p is NULL");
try{
int *p = NULL;
if (p == NULL) {
//throw myexception("p is NULL");
}
}
catch(myexception e) {
printf("%s\n", e.what());
throw;
}
catch (std::exception e) {
printf("%s", e.what());
}
B b;
}
void Func2() {
Func();
}
我们可以很明显的看到，
throw myexception("p is NULL")子句出现在了try区段之外，而注释了的
throw myexception("p is NULL")在try区段内。那么
编译器是如何知道，一个throw子句在不在try区段之内的呢？这个做法C++并没有规定，但是有一个很好的做法就是
使用program couter-range表格。program couter（程序计数器）中存放着下一个即将执行的指令。为了标志出某一段代码是否在try区段内，可以
将程序计数器的起始值和结束值存放在一个表格中。当一个异常被throw时，我们可以
比较当前的程序计数器的值是否在对应try语句的范围表格中，来决定这个throw子句是否在try区段中。如果异常不能在主调函数中被处理（或者catch之后继续抛出），程序计数器就会被设置为调用端地址，然后继续比较对应的try区段范围表格，以此往复，直到终止程序（调用terminate()函数）。
关于活动的local object：
在上面的例子，我们可以看到，在throw myexception("p is NULL")子句出现之前，a对象已经被创建在函数的堆栈中，因此它是一个
活动的local object，但是b对象还没有被创建，因此b不是活动的local object。
在栈展开的过程中，a对象将会被自动销毁（调用析构函数，如果是内置类型的话则什么都不做）。有一点需要注意的是，如果你是动态分配的内存，这个动态分配的内存是不会被释放的。
从上面的信息可以得出，下面这个流程图：
从函数堆栈的角度来看待栈展开的行为的话。还是一上面的代码为例，我们可以知道，在调用函数Func的过程中，a对象在throw子句之前，所以，在调用throw之前，程序会在Func1对应的堆栈上调用类A的构造函数，建立a对象。在调用throw之后，因为此时a对象已经在堆栈中了，而throw子句并没有与之关联的catch子句处理，因此，对象a在堆栈中的空间被释放，异常传播到Func2
中。
异常对象在发生异常而被抛出的过程中，异常对象的行为：
异常对象是一种特殊的对象，之所以说它特殊，不是因为它的类型特殊，而是因为它所存在的空间特殊。
异常对象位于编译器管理的空间中，编译器确保无论最终调用的是哪个catch子句都能访问这个空间。
当抛出异常时， 编译器使用异常抛出表达式来对异常对象进行拷贝初始化，因此，throw语句中的
表达式必须要用完整的类型（也即是要看到这个类型完整的定义，而不可以是前置声明这类声明），而且如果这个类型是类类型的话，必须还要有一个可以访问的析构函数和复制构造函数（或者移动构造函数）；如果是数组类型，则表达式会被转换成为与之对应的指针类型（指针退化）。
当执行到抛出异常的语句（也就是throw子句）， 如果throw子句是在try区段或者是不在try区段内，也不在catch子句被的话，这个
异常对象会被复制一次，无论在匹配到的catch子句中的异常声明是否是引用类型。此时，被复制的对象会被
加入到编译器的特殊空间中。如果这个时候catch子句继续抛出异常，那么就会有两种情况需要考虑：
1.匹配到的是引用类型：编译器不会生成一个副本，而是直接将catch子句中的引用绑定到上一次throw子句中的对象。
2. 匹配到的不是引用类型：编译器将会产生一个副本，而这个副本就是catch子句中声明的那个变量。
考虑下面一段代码：
#include <cstdio>
#include <cstdlib>
#include <exception>
#include <string>
class myexception : public std::exception {
public :
myexception(std::string s) : exception(s.c_str()) {
}
virtual ~myexception() {
printf("myexception's destructor\n");
}
virtual const char *what() const {
return exception::what();
}
public :
std::string _s;
};
class A {
public :
~A() {
printf("A's destructor\n");
}
};
class B {
public :
~B() {
printf("B's destructor\n");
}
};
void Func() {
A a;
printf("dasd\n");
myexception e("p is NULL");
e._s = "haha";
try{
int *p = NULL;
if (p == NULL) {
throw e;
}
}
catch(myexception &e) {
e._s = "heiheihei";
printf("%s\n", e.what()); // 这里输出 p is NULL
throw;
}
printf("%s\n", e._s.c_str());
B b;
}
void Func2() {
try {
Func();
}
catch (myexception &e) {
printf("Func2 : %s\n", e._s.c_str());
throw;
}
}
int main() {
try {
Func2();
}
catch (myexception &e) {
printf("main: %s\n", e._s.c_str());
}
printf ("hahah\n");
system("PAUSE");
return 0;
}
输出的是：
我们可以清楚的看到，当执行到Func()函数的try区段中的throw的时候，立即执行了myexception的复制构造函数，然后在查找匹配的catch子句的时候，因为
使用的都是引用类型，因此，这个被复制出来的变量不用继续被复制。而
这个异常对象会在catch子句评估确定不再抛出异常或者下一个匹配的catch不是引用类型（包括指针么？）的时候被析构。需要注意的是，如果是指针类型的话，被复制的也只是这个指针，而不是指针所指的对象。因此，如果你返回一个指向局部对象的指针，在这个局部对象被析构之后解引用这个指针的话，是会出错的。
最后，加上一个C++标准库的异常类型结构图：
异常类型 |
说明 |
exception |
最常见的问题 |
runtime_error |
只有在运行时才能检查的错误 |
range_error |
运行时错误：生成的结果超出了有意义的范围 |
overflow_error |
运行时错误：计算上溢 |
underflow_error |
运行时错误：计算下溢 |
logic_error |
程序逻辑错误 |
domain_error |
逻辑错误：参数对应的结果值不存在 |
invalid_error |
逻辑错误：无效参数 |
length_error |
逻辑错误：试图创建一个超出该类型最大长度的对象 |
out_of_range |
逻辑错误：使用一个超出有效范围的值 |
也参考：