【C++ 第十九章】异常

1.C语言传统的处理错误的方式

传统的错误处理机制：

1. 终止程序，如 assert，缺陷：用户难以接受。如发生内存错误、除 0 错误时就会终止程序。

2. 返回错误码，缺陷：需要程序员自己去查找对应的错误。如系统的很多库的接口函数都是通过把错误码放到 errno 中，表示错误

实际中C语言基本都是使用返回错误码的方式处理错误，部分情况下使用终止程序处理非常严重的错误。

2. C++异常概念

异常是一种处理错误的方式，当一个函数发现自己无法处理的错误时就可以抛出异常，让函数的
直接或间接的调用者处理这个错误

• throw:
  当问题出现时，程序会抛出一个异常。这是通过使用 throw 关键字来完成的。
• catch:
  在您想要处理问题的地方，通过异常处理程序捕获异常，catch 关键字用于捕获异常，可以有多个catch进行捕获。
• try:
  try 块中的代码标识将被激活的特定异常,它后面通常跟着一个或多个 catch 块。
  
  

如果有一个块抛出一个异常，捕获异常的方法会使用 try 和 catch 关键字。

try 块中放置可能抛出异常的代码，try 块中的代码被称为保护代码。
catch 块中放置对异常识别匹配异常类型及其异常处理代码。

使用 try/catch 语句的语法如下所示：

try
{// 保护的标识代码
}
catch( ExceptionName e1 )
{// catch 块
}
catch( ExceptionName e2 )
{// catch 块
}
catch( ExceptionName eN )
{// catch 块
}

3. 异常的使用

3.1 异常的抛出和捕获

异常的抛出和匹配原则

1. 异常是通过抛出对象而引发的，该对象的类型决定了应该激活哪个 catch 的处理代码（即类型匹配）。
2. 被选中的处理代码是调用链中与该对象 类型匹配且离抛出异常位置最近的那一个。
3. 抛出异常对象后，会生成一个异常对象的拷贝，因为抛出的异常对象可能是一个临时对象，所以会生成一个拷贝对象，这个拷贝的临时对象会在被catch以后销毁。（这里的处理类似于函数的传值返回）（原来抛出的异常对象会在原来的函数中销毁，传递的是临时对象）因这里要拷贝，因此又彰显 C++11 右值引用和移动语义的好处
4. catch(…) 可以捕获任意类型的异常，问题是不知道异常错误是什么。
5. 实际中抛出和捕获的匹配原则有个例外，并不都是类型完全匹配，可以抛出的派生类对象，
   使用基类捕获，这个在实际中非常实用，我们后面会详细讲解这个。

在函数调用链中异常栈展开匹配原则

1. 首先检查 throw 本身是否在 try 块内部，如果是再查找匹配的catch语句。如果有匹配的，则
   调到catch的地方进行处理。
2. 没有匹配的 catch 则退出当前函数栈，继续在调用函数的栈中进行查找匹配的catch。
   （当前函数没有匹配 catch，则跳到下一个函数，结束当前函数）
   （若直接调试程序观察，throw 会直接跳转到匹配 catch ，而不会一层一层跳）
3. 如果到达 main 函数的栈，依旧没有匹配的，则终止程序。上述这个沿着调用链查找匹配的catch 子句的过程称为栈展开。所以实际中我们最后都要加一个 catch(…) 捕获任意类型的异常，否则当有异常没捕获，程序就会直接终止。（如果没加上 catch(…) 会导致程序直接终止，catch(…) 是用于捕捉前面catch都不匹配的异常（相当于兜底） )

若程序终止，直接报错：

4. 找到匹配的 catch 子句并处理以后，会继续沿着catch子句后面继续执行。

第 1 点：关于 throw 语句在 try 块内部与外部的表现

void Func() {// 在 当前函数 try 块外部：不匹配该函数内部的 catch// 该 throw：匹配main函数的 catchthrow "AAAA";try {//  在 当前函数 try 块外部：匹配该函数内部的 catch// 该 throw：匹配 Func 函数的 catch（即下面这个）throw "hehe";}catch (const char* str) {cout << "Func：" << str << '\n';}
}int main() {try {Func();}catch (const char* str) {cout << "main：" << str << '\n';}return 0;
}

第 4 点：找到匹配的 catch 子句并处理以后，会继续沿着 catch 子句后面继续执行。

void Func() {throw "AAAA";
}int main() {try {Func();}catch (const char* str) {cout << "main：" << str << '\n';}// 匹配并处理 catch后，继续执行程序之后的语句cout << "hahaha" << '\n'; return 0;
}

建议：一般 try / catch 语句会放到 main 中，而不是其他子函数，以 main 函数作为异常处理的最终站

抛出异常的代码使用演示：

定义除法函数，当分母输入 0 时，抛出异常，被 Func 函数的 catch 捕捉，并打印该报错字符串

double Division(int a, int b) {if (b == 0)throw "Division by zero condition !";  // throw 任意类型，然后到函数调用的上一层去找匹配该类型的 catch，一路上一直匹配（匹配到了就停下执行 try/catch语句），直到回到 main，若还找不到则要写 catch(...) 未知错误elsereturn ((double)a / (double)b);
}void Func() {int a, b;cin >> a >> b;try{cout << Division(a, b) << '\n';}catch (const char* str) {cout << "Func：" << str << '\n';}catch (const int x) {cout << x << '\n';}
}int main() {try{Func();}catch (const char* str) {cout << "main：" <<  str << '\n';}catch (const int x) {cout << x << '\n';}catch (...) {  // 捕捉任何前面 catch 不能捕捉的异常：即未知异常cout << "unkown exception" << '\n';}// 当上面的 try/catch 语句执行完后，会继续执行 catch 后面的语句cout << "继续执行 catch 后面的语句" <<  '\n';return 0;
}

3.2 异常的重新抛出

当前函数抛出异常，相当于 return，会直接结束当前函数，跳转下一个层函数，而不执行当前函数的 throw 语句后面的代码（程序不正常执行完，会出事的！！）

⭐可能造成内存泄漏：

若当前函数后段代码时用于 释放空间资源的，此时直接被 throw 中断跳过，导致不能释放空间，而内存泄漏

写入 catch(…) 则接收任何异常，强制执行 资源释放，然后在继续 throw 抛出异常（相当于抛异常的过程中，中途截断了一下，再继续抛出）

这里的 catch(…) 不是为了处理异常，而是间接释放资源

double Division(int a, int b) {if (b == 0)throw "Division by zero condition !";  // throw 任意类型，然后到函数调用的上一层去找匹配该类型的 catch，一路上一直匹配（匹配到了就停下执行 try/catch语句），直到回到 main，若还找不到则要写 catch(...) 未知错误elsereturn ((double)a / (double)b);
}void Func()
{// 这里使用 空间int* array = new int[10];try{int len, time;cin >> len >> time;cout << Division(len, time) << endl;}catch (...){cout << "delete []" << array << endl;delete[] array;throw; // 异常重新抛出，捕获到什么抛出什么}// 如果 Division 函数抛出异常，则相当于 return 结束该函数，而不会执行下面的 delete[] // 解决方案：若写入 catch(...) 则接收任何异常，强制执行 资源释放，然后在继续 throw 抛出异常（相当于抛异常的过程中，中途截断了一下，再继续抛出v）// 这里的 catch(...) 不是为了处理异常，而是间接释放资源cout << "delete []" << array << endl;delete[] array;
}

这里还有一个坑：new 空间开辟失败会抛出异常

如果中途定义的数组 空间开辟失败，他自己也会抛出异常，结束当前函数，也就造成 array1 无法执行下面的空间释放程序

void Func()
{int* array1 = new int[10];int* array2 = new int[10];  // 如果这里空间开辟失败抛异常，则导致下面无法资源释放，内存泄漏//....
}

double Division(int a, int b) {if (b == 0)throw "Division by zero condition !";  // throw 任意类型，然后到函数调用的上一层去找匹配该类型的 catch，一路上一直匹配（匹配到了就停下执行 try/catch语句），直到回到 main，若还找不到则要写 catch(...) 未知错误elsereturn ((double)a / (double)b);
}void Func()
{// 这里使用 空间int* array1 = new int[10];//int* array2 = new int[10];  throw "array2 空间开辟失败"; // 假设定义的 array2 空间开辟失败，抛出一个异常try{int len, time;cin >> len >> time;cout << Division(len, time) << endl;}catch (...){cout << "delete []" << array1 << endl;delete[] array1;throw; // 异常重新抛出，捕获到什么抛出什么}cout << "delete []" << array1 << endl;delete[] array1;
}int main() {try{Func();}catch (const char* str) {cout << "main：" <<  str << '\n';}catch (const int x) {cout << x << '\n';}catch (...) {  // 捕捉任何前面 catch 不能捕捉的异常：即未知异常cout << "unkown exception" << '\n';}return 0;
}

如果数组被正常释放，则会打印 delete[]，显然没有，只是到 main 函数捕捉了 array2 抛出的异常

这种情况就可以使用 智能指针 处理，让智能指针管理该对象的释放（下一章讲解智能指针）

【总结】重新抛出异常 的使用

1、需要特殊处理且一次处理不完：需要对某个异常特殊处理，则先 catch，如果重新处理不了，则将 该异常继续抛出

2、需要释放资源：抛出异常的途中，有些资源需要释放，则 catch(…) 处理一下，再继续抛出 throw;

3.3异常安全

既然抛出异常会导致某段程序执行中断，就要注意以下情况

构造函数完成对象的构造和初始化，最好不要在构造函数中抛出异常，否则可能导致对象不
完整或没有完全初始化

析构函数主要完成资源的清理，最好不要在析构函数内抛出异常，否则可能导致资源泄漏(内
存泄漏、句柄未关闭等)

C++中异常经常会导致资源泄漏的问题，比如在 new 和 delete 中抛出了异常，导致内存泄
漏，在 lock 和 unlock 之间抛出了异常导致死锁，C++ 经常使用 RAII 来解决以上问题，关于 RAII
我们智能指针这节进行讲解。

3.4 异常规范（noexcept）

1. 异常规格说明的目的是为了让函数使用者知道该函数可能抛出的异常有哪些。 可以在函数的
   后面接throw(类型)，列出这个函数可能抛掷的所有异常类型。
2. 函数的后面接throw()，表示函数不抛异常。
3. 若无异常接口声明，则此函数可以抛掷任何类型的异常。
   
   

// 这里表示这个函数会抛出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; // 写上 noexcept 表示这里一定没有异常，如果有异常，但也写了这个，会报警告

4.自定义异常体系

实际使用中很多公司都会自定义自己的异常体系进行规范的异常管理，因为一个项目中如果大家随意抛异常，那么外层的调用者基本就没办法玩了，所以实际中都会定义一套继承的规范体系。这样大家抛出的都是继承的派生类对象，捕获一个基类就可以了

前面讲解：异常捕捉，类型一定要严格匹配，不出现类型转换

但是存在一个例外：可以抛出子类对象异常，使用父类捕获（这个很实用）

比如我们设计一个 包含一些基础异常信息的父类

上层程序都将抛出的异常封装到该父类的子类

下层程序使用父类指针匹配 catch 抛出包含异常信息的子类或父类对象或未知异常，这样既能够 catch 到已知的所有异常，并且能够通过捕捉到的 对象，获得到许多信息

例如：聊天服务器开发中通常使用的异常继承体系

（2）若发送成功，则调用 CacheMsg 函数存入存储，存储失败也有两种可能：1、权限不足；2、数据不存在；

（3）抛出异常对象，会被 main 函数的 catch 捕捉，利用多态，分析是发送信息异常对象 or 数据存储异常对象，并解析异常信息，打印成日志

main 函数中 catch 只需设置成 父类指针或引用就能接收到 来自不同子类的对象，使得异常的捕获方便许多

因为业务开发，服务通常一直运行不间断，因此我这里直接设置 while(1) 死循环，一直运行

#include<thread>
#include<time.h>
#include<windows.h>// 服务器开发中通常使用的异常继承体系// 包含异常信息的父类
class Exception
{
public:Exception(const string& errmsg, int id):_errmsg(errmsg), _id(id){}virtual string what() const{return _errmsg;}int getid() const{return _id;}protected:string _errmsg;int _id;
};// 下面开发业务中的所有功能模块类（CacheException、HttpServerException）都继承上面这个 父类
// 以父类为基础，自己再添加本功能模块 需要抛出的异常信息
class CacheException : public Exception
{
public:CacheException(const string& errmsg, int id):Exception(errmsg, id){}virtual string what() const{string str = "CacheException:";str += _errmsg;return str;}
};class HttpServerException : public Exception
{
public:HttpServerException(const string& errmsg, int id, const string& type):Exception(errmsg, id), _type(type){}virtual string what() const{string str = "HttpServerException:";str += _type;str += ":";str += _errmsg;return str;}private:const string _type;
};void CacheMgr()
{if (rand() % 5 == 0){throw CacheException("权限不足，无法存储", 100);}else if (rand() % 6 == 0){throw CacheException("数据不存在，存储失败", 101);}
}void sendmsg(const string& s)
{if (rand() % 2 == 0){throw HttpServerException("网络不稳定，发送失败", 102, "put");}else if (rand() % 3 == 0){throw HttpServerException("你已经不是对象的好友，发送失败", 103, "put");}else{cout << "发送成功" << "\n\n";}
}void HttpServer()
{// 失败以后，再重试3次// 发送 1 次 + 重试3次 = 4次for (size_t i = 0; i < 4; i++){try{// 调用发送信息模块sendmsg("今天一起看电影吧");break; // 若发送成功，这里就会直接 break; 若发送不成功，sendmsg 函数里面会抛异常，并下面这个 catch 捕获：若信息发送不成功是 102 号网络问题，则会重试（即继续for循环）}catch (const Exception& e){if (e.getid() == 102) // 这里反映错误id 的用处：针对某种错误特殊处理（而不用匹配错误字符串码）{if (i == 3)  // 重试 3 次都没有成功，则抛异常（也相当结束当前）throw e;cout << "开始第" << i + 1 << "重试" << endl;}else{throw e;   // 只要不是 102号错误，将捕获的异常重新抛出：相当于发送失败，不重试了，并把错误信息再次抛出，到 main 函数处再解析}}}CacheMgr();  // 信息发送成功后，把信息存入存储
}int main()
{srand(time(0));int i = 0; // 表示当前是第几轮发送信息while (1){this_thread::sleep_for(chrono::seconds(1));cout << "|——————开始第 " << ++i << " 轮发送信息测试——————|" << endl;try{// 请求网络服务：发送聊天信息HttpServer();}catch (const Exception& e) // 这里捕获父类对象就可以{// 捕获异常，解析异常对象中的 异常信息，同时打印当前时间using std::chrono::system_clock;// 多态system_clock::time_point today = system_clock::now(); // 获取当前时间std::time_t tt = system_clock::to_time_t(today);cout << ctime(&tt) << e.what() << "\n\n\n";}catch (...){cout << "Unkown Exception" << endl;}}return 0;
}

运行演示

5.C++标准库的异常体系

C++ 提供了一系列标准的异常，定义在库中，我们可以在程序中使用这些标准的异常。它们是以父
子类层次结构组织起来的，如下所示：

int main()
{try {vector<int> v(10, 5);// 这里如果系统内存不够也会抛异常v.reserve(1000000000);// 这里越界会抛异常v.at(10) = 100;}catch (const exception& e) // 这里捕获父类对象就可以{cout << e.what() << endl;}catch (...){cout << "Unkown Exception" << endl;}return 0;
}

6.异常的优缺点

C++异常的优点：

1. 异常对象定义好了，相比错误码的方式可以清晰准确的展示出错误的各种信息，甚至可以包
   含堆栈调用的信息，这样可以帮助更好的定位程序的 bug。
2. 返回错误码的传统方式有个很大的问题就是，在函数调用链中，深层的函数返回了错误，那
   么我们得层层返回错误，最外层才能拿到错误，具体看下面的详细解释。

// 1.下面这段伪代码我们可以看到ConnnectSql中出错了，先返回给ServerStart，
ServerStart再返回给main函数，main函数再针对问题处理具体的错误。
// 2.如果是异常体系，不管是ConnnectSql还是ServerStart及调用函数出错，都不用检查，因
为抛出的异常异常会直接跳到main函数中catch捕获的地方，main函数直接处理错误。
int ConnnectSql()
{// 用户名密码错误if (...)return 1;// 权限不足if (...)return 2;
}int ServerStart() {if (int ret = ConnnectSql() < 0)return ret;int fd = socket()if（fd < 0）return errno;
}int main()
{if (ServerStart() < 0)...return 0;
}

3. 很多的第三方库都包含异常，比如boost、gtest、gmock等等常用的库，那么我们使用它们
   也 需要使用异常。

4. 部分函数使用异常更好处理，比如构造函数没有返回值，不方便使用错误码方式处理。比如
   T& operator[] 这样的函数，如果 pos 越界了只能使用异常或者终止程序处理，没办法通过返回值表示错误。

C++异常的缺点：

1. 异常会导致程序的执行流乱跳，并且非常的混乱，并且是运行时出错抛异常就会乱跳。这会
   导致我们跟踪调试时以及分析程序时，比较困难。
2. 异常会有一些性能的开销。当然在现代硬件速度很快的情况下，这个影响基本忽略不计。
3. C++没有垃圾回收机制，资源需要自己管理。有了异常非常容易导致内存泄漏、死锁等异常安全问题。这个需要使用RAII来处理资源的管理问题。学习成本较高。
4. C++标准库的异常体系定义得不好，导致大家各自定义各自的异常体系，非常的混乱。
5. 异常尽量规范使用，否则后果不堪设想，随意抛异常，外层捕获的用户苦不堪言。所以异常
   规范有两点：一、抛出异常类型都继承自一个基类。二、函数是否抛异常、抛什么异常，都
   使用 func（） throw();的方式规范化。（公司中为了规范，一般都会要求做这些规范，如
   果你确定这里不会抛异常就加上 noexcept）
   
   

总结：异常总体而言，利大于弊，所以工程中我们还是鼓励使用异常的。另外OO的语言基本都是用异常处理错误，这也可以看出这是大势所趋。