一.异常
1. 异常的概念及使用
1.1 异常的概念
-
异常处理机制允许程序中独立开发的部分能够在运行时就出现的问题进行通信并做出相应的处理，异常使得我们能够将问题的检测与解决问题的过程分开，程序的⼀部分负责检测问题的出现，然后解决问题的任务传递给程序的另⼀部分，检测环节无须知道问题的处模块的所有细节。
-
C语言主要通过错误码的形式处理错误，错误码本质就是对错误信息进行分类编号，拿到错误码以后还要去查询错误信息，比较麻烦。异常时抛出⼀个对象，这个对象可以函盖更全面的各种信息。
1.2 异常的抛出和捕获
-
程序出现问题时，我们通过抛出(throw)⼀个对象来引发⼀个异常，该对象的类型以及当前的调用链决定了应该由哪个catch的处理代码来处理该异常。
行话：
"类型匹配 + 最先遇到"原则，和函数重载一样，只允许标准转换（派生→基、数组→指针、函数→函数指针），不允许算术转型。
人话：
抛一只"猫"，只有形参是"猫"或"动物"的 catch 能接得住；形参是"狗"或"int"就接不住，继续往调用栈的上一层跳。
cpp#include <iostream> struct Cat { virtual ~Cat(){} }; struct Dog : Cat {}; void foo() { throw Dog{}; // 抛出的是 Dog 对象 } int main() { try { foo(); } catch(Dog&) { std::cout << "catch Dog\n"; } // ① 最先遇到且类型匹配 → 命中 catch(Cat&) { std::cout << "catch Cat\n"; } // ② 也匹配，但排在后面 → 不会进来 }
-
被选中的处理代码是调用链中与该对象类型匹配且离抛出异常位置最近的那⼀个。根据抛出对象的类型和内容，程序的抛出异常部分告知异常处理部分到底发生了什么错误。
-
当throw执行时，throw后面的语句将不再被执行。
cppvoid test() { std::cout << "before throw\n"; throw 42; std::cout << "after throw (永远看不到)\n"; } int main() { try { test(); } catch(int) { std::cout << "caught 42\n"; } } 输出： before throw caught 42 -
程序的执行从throw位置跳到与之匹配的catch模块，catch可能是同⼀函数中的⼀个局部的catch，也可能是调用链中另⼀个函数中的catch，控制权从throw位置转移到了catch位置。这里还有两个重要的含义：1、沿着调用链的函数可能提早退出。2、⼀旦程序开始执行异常处理程序，沿着调用链创建的对象都将销毁。
行话：
栈展开（stack unwinding）------ 对每一帧自动调用局部对象析构，然后弹栈。
人话：
函数调用像俄罗斯套娃，抛异常后一层层把娃拆掉，直到找到能抱住它的 catch。
cpp#include <iostream> struct Obj { ~Obj() { std::cout << "Obj 析构\n"; } }; void inner() { Obj o; throw 1; } // 这里抛 void middle() { Obj o; inner(); } // 展开时 o 被析构 void outer() { Obj o; middle(); } // 再展开 o 被析构 int main() { try { outer(); } catch(...) { std::cout << "到达 main 的 catch\n"; } } 输出： Obj 析构 Obj 析构 Obj 析构 到达 main 的 catch
- 抛出异常对象后，会生成⼀个异常对象的拷贝，因为抛出的异常对象可能是⼀个局部对象，所以会生成⼀个拷贝对象，这个拷贝的对象会在catch子句后销毁。（这里的处理类似于函数的传值返回）
行话：
throw 表达式先构造一次局部对象，再拷贝（或移动）到编译器管理的"异常对象"区，catch 里拿到的引用指向的是这份拷贝。
人话：
怕你抛出去以后函数栈回收把原对象冲掉，编译器先帮你复印一份存到安全屋。
cpp#include <iostream> struct E { E() { std::cout << "E 构造\n"; } E(const E&){ std::cout << "E 拷贝\n"; } ~E() { std::cout << "E 析构\n"; } }; void foo() { E e; // ① 构造 throw e; // ② 拷贝到"异常对象"区；原 e 随后析构 } int main() { try { foo(); } catch(E& ex){ std::cout << "catch 中引用的是拷贝对象\n"; } // ③ catch 结束后，拷贝对象再析构 } 输出： E 构造 E 拷贝 E 析构 // 这是局部 e 被销毁 catch 中引用的是拷贝对象 E 析构 // 这是异常拷贝对象被销毁
cpp
double Divide(int a, int b)
{
try
{
if (b == 0)
{
string s = "Divide by zero condition!";
throw s;
}
else
{
return a / b;
}
}
catch (int errid)
{
cout << errid << endl;
}
return 0;
}
void func()
{
int len, time;
cin >> len >> time;
try
{
cout << Divide(len, time) << endl;
}
catch (const char* errmsg)
{
cout << errmsg << endl;
}
cout << __FUNCTION__ << ":" << __LINE__ << "行执行" << endl;
}
int main()
{
while (1)
{
try
{
func();
}
catch (const string& errmsg)
{
cout << errmsg << endl;
}
}
}
详细流程（b == 0 时）
-
Divide里throw s;抛出的是std::string对象。 -
Divide自己的catch(int)类型不符，不匹配。 -
栈展开：
Divide帧结束，局部变量s析构，函数返回语句不再执行。 -
回到
func的调用点：func里只有catch(const char*)，仍然不匹配。 -
继续展开：
func帧结束，控制流回到main。 -
main的try块外有catch(const string&)，类型完全匹配 ，异常在此处被捕获，打印"Divide by zero condition!"。 -
捕获后程序继续执行
while(1)的下一轮循环。
1.3 栈展开
- 抛出异常后，程序暂停当前函数的执行，开始寻找与之匹配的catch子句，首先检查throw本身是否在try块内部，如果在则查找匹配的catch语句，如果有匹配的，则跳到catch的地方进行处理。
- 如果当前函数中没有try/catch子句，或者有try/catch子句但是类型不匹配，则退出当前函数，继续在外层调用函数链中查找，上述查找的catch过程被称为栈展开。
- 如果到达main函数，依旧没有找到匹配的catch子句，程序会调用标准库的 terminate 函数终止程序。
- 如果找到匹配的catch子句处理后，catch子句代码会继续执行。
1.4 查找匹配的处理代码
-
一般情况下抛出对象和catch是类型完全匹配的，如果有多个类型匹配的，就选择离他位置更近的那个。
-
但是也有⼀些例外，允许从非常量向常量的类型转换，也就是权限缩小；允许数组转换成指向数组元素类型的指针，函数被转换成指向函数的指针；允许从派生类向基类类型的转换，这个点非常实用，实际中继承体系基本都是用这个方式设计的。
-
如果到main函数，异常仍旧没有被匹配就会终止程序，不是发生严重错误的情况下，我们是不期望程序终止的，所以一般main函数中最后都会使用catch(...)，它可以捕获任意类型的异常，但是是不知道异常错误是什么。
cpp#include<thread> #include<iostream> using namespace std; // ⼀般⼤型项⽬程序才会使⽤异常，下⾯我们模拟设计⼀个服务的⼏个模块 // 每个模块的继承都是Exception的派⽣类，每个模块可以添加⾃⼰的数据 // 最后捕获时，我们捕获基类就可以 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; }; class SqlException : public Exception { public: SqlException(const string& errmsg, int id, const string& sql) :Exception(errmsg, id) , _sql(sql) {} virtual string what() const { string str = "SqlException:"; str += _errmsg; str += "->"; str += _sql; return str; } private: const string _sql; }; 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 HttpException : public Exception { public: HttpException(const string& errmsg, int id, const string& type) :Exception(errmsg, id) , _type(type) {} virtual string what() const { string str = "HttpException:"; str += _type; str += ":"; str += _errmsg; return str; } private: const string _type; }; void SQLMgr() { if (rand() % 7 == 0) { throw SqlException("权限不⾜", 100, "select * from name = '张三'"); } else { cout << "SQLMgr 调⽤成功" << endl; } } void CacheMgr() { if (rand() % 5 == 0) { throw CacheException("权限不⾜", 100); } else if (rand() % 6 == 0) { throw CacheException("数据不存在", 101); } else { cout << "CacheMgr 调⽤成功" << endl; } SQLMgr(); } void HttpServer() { if (rand() % 3 == 0) { throw HttpException("请求资源不存在", 100, "get"); } else if (rand() % 4 == 0) { throw HttpException("权限不⾜", 101, "post"); } else { cout << "HttpServer调⽤成功" << endl; CacheMgr(); } } int main() { srand(time(0)); while (1) { this_thread::sleep_for(chrono::seconds(1)); try { HttpServer(); } catch (const Exception& e) // 这⾥捕获基类，基类对象和派⽣类对象都可以被捕获 { cout << e.what() << endl; } catch (...) { cout << "Unkown Exception" << endl; } } return 0; }
1.5 异常重新抛出
有时catch到⼀个异常对象后，需要对错误进行分类，其中的某种异常错误需要进行特殊的处理，其他错误则重新抛出异常给外层调用链处理。捕获异常后需要重新抛出，直接 throw; 就可以把捕获的对象直接抛出。
1.6 异常安全问题
- 异常抛出后，后面的代码就不再执行，前面申请了资源(内存、锁等)，后面进行释放，但是中间可能会抛异常就会导致资源没有释放，这里由于异常就引发了资源泄漏，产生安全性的问题。中间我们需要捕获异常，释放资源后面再重新抛出，当然后面智能指针章节讲的RAII方式解决这种问题是更好的。
- 其次析构函数中，如果抛出异常也要谨慎处理，比如析构函数要释放10个资源，释放到第5个时抛出异常，则也需要捕获处理，否则后面的5个资源就没释放，也资源泄漏了。《Effctive C++》第8个条款也专们讲了这个问题，别让异常逃离析构函数。
1.7 异常规范
- 对于用户和编译器而言，预先知道某个程序会不会抛出异常大有裨益，知道某个函数是否会抛出异常有助于简化调用函数的代码。
- C++98中函数参数列表的后面接throw()，表示函数不抛异常，函数参数列表的后面接throw(类型1,类型2...)表示可能会抛出多种类型的异常，可能会抛出的类型⽤逗号分割。
- C++98的方式这种方式过于复杂，实践中并不好用，C++11中进行了简化，函数参数列表后面加noexcept表示不会抛出异常，啥都不加表示可能会抛出异常。
- 编译器并不会在编译时检查noexcept，也就是说如果⼀个函数用noexcept修饰了，但是同时又包含了throw语句或者调用的函数可能会抛出异常，编译器还是会顺利编译通过的(有些编译器可能会报个警告)。但是⼀个声明了noexcept的函数抛出了异常，程序会调用 terminate 终止程序。
- noexcept(expression)还可以作为⼀个运算符去检测⼀个表达式是否会抛出异常，可能会则返回false，不会就返回true。
二. 标准库的异常
cpp
class exception {
public:
exception () noexcept;
exception (const exception&) noexcept;
exception& operator= (const exception&) noexcept;
virtual ~exception();
virtual const char* what() const noexcept;
}- 官方链接
- C++标准库也定义了⼀套自己的⼀套异常继承体系库，基类是exception，所以我们日常写程序，需要在主函数捕获exception即可，要获取异常信息，调⽤what函数，what是⼀个虚函数，派⽣类可以重写。
后言
这就是C++的异常机制。大家自己好好消化！今天就分享到这！感谢各位的耐心垂阅！