本文详细探讨了C++中的异常处理机制，包括其基本概念、抛出和匹配规则、优点（如清晰的错误信息和方便的错误传递）以及缺点（如执行流的混乱和可能导致的资源管理问题）。还讨论了异常安全和规范的重要性，以及与传统错误处理方式的区别。
异常处理机制
C语言传统的处理错误的方式
传统的错误处理机制
- 出现错误直接终止程序，比如assert
- 返回错误码：C语言库中很多处理程序都是通过将错误码放到errno中，为调用者提供错误信息
以上两种处理错误的方式都有一定的缺陷，比如当使用assert时，如果发生错误，则会直接强行终止掉整个程序，而一般情况下我们往往是希望当出现错误情况时，程序还是可以正常运行以确保用户的使用；当使用返回错误码的方式时，需要程序员自己去获取对应的错误码，并根据错误码得到对应的错误信息，这种方法也不是很方便
C++异常概念
异常是一种处理错误的方式，当一个函数发现一个自己无法处理的错误时就可以将异常抛出，让该函数的直接或者是间接调用者去处理这个错误
要认识C++中的异常机制，首先要认识三个与异常有关的关键字
- throw:当问题出现后，程序就会抛出一个异常，抛出异常的操作就是通过
throw关键字实现的 - catch:这个关键字主要出现在你想处理错误的地方，它的作用就是用来将
throw抛出的异常进行捕获，并且根据抛出的异常的类型的不同，可以同时存在多个catch关键字来捕获不同类型的异常 - try:
try块中的代码标识符将被激活的特定异常，它后面跟着的通常是一个或者是多个catch代码块
如果有一个代码块中有异常被抛出，捕获这个异常需要用到try和catch关键字，try块中放置可能抛出异常的代码(try中的代码被称为是保护代码)
try
{
//保护的标识代码
}
catch (const std::exception& e1)
{
//catch块
}
catch (const std::exception& e2)
{
//catch块
}
catch (const std::exception& e3)
{
//catch块
}
异常的使用
异常的抛出和匹配规则
1、异常通常是抛出对象而引发的，该对象的类型决定了应该激活哪个catch块中的处理代码
int main()
{
try
{
throw "出现异常";
}
catch(const char*str)
{
cout << "捕获到const char*类型的异常对象" << endl;
}
catch (int err)
{
cout << "捕获到int类型的异常对象" << endl;
}
catch (double err)
{
cout << "捕获到double类型的异常对象" << endl;
}
return 0;
}
因为这里抛出的是一个常量字符串，由于规则中对象类型决定了会被哪个catch所捕捉，所以自然就会被第一个catch给捕获
2、被选中的处理代码是调用链中与该对象类型匹配且离抛出异常位置最近的那一个
int test(int a,int b)
{
if (b == 0)
{
throw "Division by zero condition";
}
else
{
return a / b;
}
}
void func()
{
try
{
test(10,0);
}
catch (const char*errmsg)
{
cout << "在func中捕获:";
cout << errmsg << endl;
}
}
int main()
{
try
{
func();
}
catch (const char* errmsg)
{
cout << "在main函数中捕获:";
cout << errmsg << endl;
}
return 0;
}
可以看到，虽然在函数func和main函数中都有捕获异常的机制，并且两个函数的捕获机制都是一样的，但是在调用链中(main函数调用func，func中调用test,即main->func->test)，在整个调用链中，距离test最近的的是func中的catch语句，所以最后test中抛出的异常最终被func给捕获到
3、抛出异常对象之后，会生成一个异常对象的拷贝，因为抛出的异常对象可能是一个临时对象(出了作用域就会被销毁)，所以会生成一个拷贝对象(这里的拷贝通常是移动拷贝，因为原来的对象出了作用域就会被销毁的缘故，就可以把它当作是一个将亡值)。
这个拷贝的临时对象会在被catch之后销毁(这里的处理机制类似于函数的传值返回)
4、catch…可以捕获任意类型的异常，但是使用这种方式捕捉异常会导致不知道异常的类型是什么
5、实际中抛出和捕获的匹配原则有个例外，并不是都是类型完全匹配，可以抛出一个派生类对象，但是捕获的使用使用基类捕获，这个方法在实际中经常使用(在C++标准库中处理异常就是用这个方法)
class exception {
public:
exception () noexcept;
exception (const exception&) noexcept;
exception& operator= (const exception&) noexcept;
virtual ~exception();
virtual const char* what() const noexcept;
}
图片中的例如bad_alloc、bad_cast等等都是继承的exception这个类，所以当抛出的是C++标准库中的异常时，就可以使用exception这个类型来统一接收，并且通过多态的性质可以查看具体抛出的哪一种异常
#include<functional>
#define SIZE 1e10
int main()
{
try
{
//当通过new申请空间过大时，系统就会抛出bad_alloc对象，然后被exception类型所接收
int* a = new int[SIZE];
}
catch (const std::exception&e)
{
cout << e.what() << endl;
}
return 0;
}
在函数调用链中异常栈展开匹配原则
1、首先检查throw本身是否在try块内部，如果是则再查找匹配的catch语句，如果当前有匹配的，则调到catch的地方进行处理
2、没有匹配的catch则退出当前函数栈，继续在调用函数的栈中进行查找匹配的catch
3、如果一直到main函数调用栈依旧没有匹配的，则会直接退出程序(即整个程序直接终止)。上面所讲到的沿着调用链查找匹配的catch语句的过程称为栈展开，所以我们通常会在最后都要加上一个catch(…)用来捕获任意类型的异常，否早当出现有异常没有被成功捕获，这个程序就会直接终止
void func1()
{
throw "err";
}
void func2()
{
func1();
}
void func3()
{
func2();
}
int main()
{
try
{
func3();
}
catch (const char*errmsg)
{
cout << errmsg << endl;
}
return 0;
}
4、找到匹配的catch语句并将异常进行处理之后，会继续沿着catch语句之后继续执行(异常发生后的语句就像当于是直接跳过了，不会再执行)
void test()
{
throw "发生异常";
cout << "异常发生之后" << endl;
}
int main()
{
try
{
test();
}
catch (const char* errmsg)
{
cout << "捕获异常" << endl;
}
cout << "捕获异常之后" << endl;
return 0;
}
异常的重新抛出
有的时候单个的catch语句并不能完全处理一个异常，而是在进行一些处理之后，希望再交给更外层的调用链函数进行处理，catch可以通过重新抛出将异常传递给更上层的函数进行处理
#include<array>
void test()
{
std::array<int, 3>arr;
cout << arr.at(4) << endl;//在array中使用at方法越界访问会抛出异常
}
void func()
{
int* p = new int(1);
try
{
test();
}
catch (...)
{
delete p;
throw;//捕到什么抛什么
}
delete p;
}
int main()
{
try
{
func();
}
catch (const std::exception&e)
{
cout << e.what() << endl;
}
return 0;
}
简单分析以下以上代码，在test()函数中发生了越界访问时，由于array的实现机制，越界访问就会抛出异常，由于test函数内部没有匹配的catch语句捕获异常，所以test函数栈帧直接被释放，程序直接根据调用链到func函数中寻找
在func函数中我们可以看到在函数的开头有一个指针指向的是堆区申请的空间，如果说，我们不想在func函数中处理异常，我们肯定是要重新将该异常抛出的，但是根据直接异常处理的规则可以知道，一旦将异常重新抛出之后，func函数栈帧会被直接释放，程序直接跳到main函数中，但是指针p所指向的空间资源并没有被释放，这个时候就会导致内存泄漏问题，所以在catch语句中还需要在重新抛出异常之前就释放之前申请的资源
传统指针处理异常的缺陷
我们知道，当我们使用new关键字来申请空间时，如果说因为空间资源不足或者是其他原因会导致申请空间失败，并会直接抛出异常
由刚才的例子我们知道，但我们重新抛出异常的时候，后面的代码就不会被再次执行了，这就会引发野指针的问题，所以当我们多次用new申请空间时，每次new的时候就需要考虑当new引发异常后该怎么避免野指针的问题
void func()
{
int* p1 = new int[10];
int* p2, * p3;
try
{
p2 = new int[20];
try {
p3 = new int[30];
}
catch (...)
{
delete[] p1;
delete[] p2;
throw;
}
}
catch (...)
{
delete[] p1;
throw;
}
}
int main()
{
try
{
func();
}
catch (const std::exception& e)
{
cout << e.what() << endl;
}
return 0;
}
可以看到，如果我们每次new的时候都考虑申请失败的话，就需要按照上面的写法，但是这样写无论是从可读性还是代码编写的角度来看都太过不方便，所以C++又有一种东西叫做智能指针，就是来解决类似这样的问题的，智能指针的内容我会放到下篇博客进行讲解
异常安全
- 构造函数完成对象的构造和初始化，最好不要在构造函数中抛出异常，否则可能导致对象不
完整或没有完全初始化 - 析构函数主要完成资源的清理，最好不要在析构函数内抛出异常，否则可能导致资源泄漏(内 存泄漏、句柄未关闭等)
- C++中异常经常会导致资源泄漏的问题，比如在new和delete中抛出了异常，导致内存泄
漏，在lock和unlock之间抛出了异常导致死锁，C++经常使用RAII来解决以上问题
异常规范
- 异常规格说明的目的是为了让函数使用者知道该函数可能抛出的异常有哪些。 可以在函数的
后面接throw(类型)，列出这个函数可能抛掷的所有异常类型。 - 函数的后面接throw()，表示函数不抛异常。
- 若无异常接口声明，则此函数可以抛掷任何类型的异常
// 这里表示这个函数会抛出A/B/C/D中的某种类型的异常
void fun() throw(A，B，C，D);
// 这里表示这个函数只会抛出bad_alloc的异常
void* operator new (std::size_t size) throw (std::bad_alloc);
// 这里表示这个函数不会抛出异常
void* operator delete (std::size_t size, void* ptr) throw();
// C++11 中新增的noexcept，表示不会抛异常
thread() noexcept;
thread (thread&& x) noexcept;
我们经常会在C++标准库中看到以上规范
但是这些规范仅仅能起到的作用实在是有限，比如可能有这样一个函数，这个函数的声明中有noexcept关键字，但是这个函数却可以抛出异常，关键是这样的代码可以在有的编译器上被编译通过！！！(当然现在检查严格的编译器还是编译不通过的)
发生异常时也仅仅只是警告,这对于查找bug来说是非常不友好的
异常的优缺点
异常的优点
- 异常对象定义好了，相比错误码的方式可以清晰准确的展示出错误的各种信息，甚至可以包
含堆栈调用的信息，这样可以帮助更好的定位程序的bug。 - 返回错误码的传统方式有个很大的问题就是，在函数调用链中，深层的函数返回了错误，那
么我们得层层返回错误，最外层才能拿到错误，但是异常可以直接跳过多层函数栈帧，不用层层处理，更加方便 - 很多的第三方库都包含异常，比如boost、gtest、gmock等等常用的库，那么我们使用它们
也需要使用异常 - 部分函数使用异常更好处理，比如构造函数没有返回值，不方便使用错误码方式处理。比如
T& operator这样的函数，如果pos越界了只能使用异常或者终止程序处理，没办法通过返回
值表示错误。
异常的缺点
- 异常会导致程序的执行流乱跳，并且非常的混乱，并且是运行时出错抛异常就会乱跳。这会
导致我们跟踪调试时以及分析程序时，比较困难。 - C++没有垃圾回收机制，资源需要自己管理。有了异常非常容易导致内存泄漏、死锁等异常
安全问题。 - C++标准库的异常体系定义得不好，导致大家各自定义各自的异常体系，非常的混乱。
- 异常尽量规范使用，否则后果不堪设想，随意抛异常，外层捕获的用户苦不堪言。所以异常
规范有两点：一、抛出异常类型都继承自一个基类。二、函数是否抛异常、抛什么异常，都
使用try、catch的方式规范化。
2768
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
