异常和异常体系
约 3388 字大约 11 分钟
2025-06-21
1.传统错误
在C语言中，传统的错误处理方式有：
assert()，缺陷就是太过于武断，会直接终止程序，并且只能在debug模式下才可以起作用- 返回错误码，在
Linux编程中就十分常见，但是对于很深层的系统调用，传递给最外层的main()函数时需要很多的返回语句，并且不是所有函数都可以返回错误码的（例如：类的几大成员函数，构造函数、析构函数等）
因此实际上C都是通过错误码来处理错误的，部分情况下使用终止程序处理严重错误。
2.异常概念
C++的异常是一种处理错误的方式，当一个函数发现自己无法处理某个错误时，就可以抛出异常，让函数直接或间接的调用者处理这个错误。
throw：当问题出现时，通过使用throw关键字，程序就会抛出某个类型的异常catch：该关键字可以捕获异常，可以设置多个类型的捕获try：try块中的代码标识将被激活的某些异常，它后面通常跟着一个或多个catch块，异常通常在这里被抛出，捕获异常则会使用catch
3.异常使用
throw /*抛出异常*/
//...
try {
//正常执行
}
catch (/*接收异常*/){
//代码 1
}
catch (/*接收异常*/){
//代码 2
}
catch (/*接收异常*/){
//代码 2
}假设我们写一个除法，有可能出现除零错误
#include <iostream>
using namespace std;
class Data
{
public:
Data(int data = 100)
: _data(data)
{
cout << "构造" << '\n';
}
~Data()
{
cout << "析构 " << '\n';
}
private:
int _data;
};
double Division(int left, int right)
{
if (right == 0)
{
throw "除零错误";
}
return (double)left / (double)right;
}
void Func()
{
Data d1;//虽然抛出异常，但是这里的析构也会调用
int left, right;
cin >> left >> right;
cout << Division(left, right) << '\n';
Data d2;//如果发生除零错误，这里以后代码就不会被执行，因此 d2 不会调用构造和析构
}
int main()
{
//一般都在外层代码捕获
try
{
Func();
}
catch (const char* str)
{
cout << str << '\n';
}
catch (...)
{
cout << "Other" << '\n';
}
return 0;
}在函数调用链中异常栈的展开匹配原则：
- 首先检查
throw本身是否在try块内部 - 如果是再查找匹配的
catch语句 - 如果有匹配的接受异常的类型，则调到
catch的地方进行处理（这一行为很像函数的传参，抛出的异常对象可能是一个临时对象，所以会生成一个拷贝对象，这个拷贝的临时对象会在catch后销毁） - 没有匹配的
catch则退出当前函数栈，继续在调用函数的栈中进行查找匹配的catch - 如果到达
main函数的栈，依旧没有匹配的，则终止程序（行为类似assert）
上述这个沿着调用链查找匹配的catch子句的过程称为“栈展开”。所以实际中我们最后都要加一个catch(...)捕获任意类型的异常，否则当有遗漏的异常没被捕获，程序就会像assert()一样直接终止程序。
而找到匹配的catch子句并处理以后，会继续沿着catch子句后面继续执行。
另外，关于异常还有一些其他的语法和关键字。
//这里表示这个函数会抛出 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;还有些时候单个catch不能完全处理一个异常，在进行一些校正后，希望再交给更外层的调用链来处理，catch则可以通过语句throw;重新抛出，则将异常传递给更上层的函数处理。
#include <iostream>
using namespace std;
double Division(int a, int b)
{
if (b == 0)
{
throw "Division by zero condition";
}
return (double)a / (double)b;
}
void Function()
{
int* array_1 = new int[10];//(6)new 本身也会抛出异常
int* array_2 = new int[10];//(7)new 本身也会抛出异常
try
{
int len, time;
cin >> len >> time;
cout << Division(len, time) << '\n';//(1)假设抛出“除零异常”
}
catch (...)//(2)“除零异常”被代码拦截下来
{
//(3)先释放 array，防止内存泄露
cout << "delete_1[] " << array_1 << '\n';
delete[] array_1;
cout << "delete_2[] " << array_2 << '\n';
delete[] array_2;
throw;//(4)重新将异常抛出去
}
cout << "delete_1[] " << array_1 << '\n';
delete[] array_1;
cout << "delete_2[] " << array_2 << '\n';
delete[] array_2;
}
int main()
{
try
{
Function();
}
catch (const char* error)//(5)“除零错误”会在这里被接收
{
cout << error << endl;
}
catch (const exception& e)//(8)new 的异常可以在这里被接收
{
cout << e.what() << '\n';
}
return 0;
}补充：这里假设有多个
array资源，释放起来代码就会很长，我在下一篇文章《C++智能指针》会使用智能指针优化这一过程。
另外 noexcept 明确函数不会抛出异常。
4.异常安全
异常的使用会让C++产生一些新的错误导致程序出现严重问题，因此我们需要遵循一些代码要求，避免危险的情乱：
- 构造函数完成对象的构造和初始化，最好不要在构造函数内抛出异常，否则可能导致对象构造不完整或没有完全初始化
- 析构函数完成对象的资源清理，最好不要在析构函数内抛出异常，否则可能导致资源泄漏（内存泄漏、句柄未关闭等等）
补充
1：C++中的异常经常会导致资源泄漏的问题，比如在new和delete中抛出了异常，导致内存泄漏，在lock和unlock之间抛出了异常导致死锁，C++经常使用RAII来解决以上问题，关于RAII我们智能指针这节进行讲解。补充
2：异常没被捕获时，编译器一般都会调用abort()强行终止程序，像VS 2022就会弹出一个带有提示为abort() has been called的弹窗。
5.异常体系
但是异常如果没有一定的规范，就会导致程序迅速终止，这是比较严重的结果，因此就需要一种异常体系的规范，最典型的规范就是使用继承来防范异常的危险。
假设技术团队设计了一个父类，所有人只能抛出继承自父类的子类，这样只需要捕获父类对象即可（有切片和多态的存在就会很方便）。
这里模拟了一个后端服务器运行过程中子类抛异常，父类捕获异常的过程：
#include <iostream>
#include <thread>
using namespace std;
//服务器开发中通常使用的异常继承体系
class Exception
{
public:
Exception(const string& errmsg, int id)
:_errmsg(errmsg),
_id(id)
{}
//查询错误
virtual string what() const
{
return _errmsg;
}
protected:
string _errmsg; //错误信息
int _id; //错误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 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 SQLMgr()
{
srand(time(0));
if (rand() % 7 == 0)
{
throw SqlException("权限不足", 100, "select * from name = '张三'");
}
//throw "xxxxxx";
}
void CacheMgr()
{
srand(time(0));
if (rand() % 5 == 0)
{
throw CacheException("权限不足", 100);
}
else if (rand() % 6 == 0)
{
throw CacheException("数据不存在", 101);
}
SQLMgr();
}
void HttpServer()
{
// ...
srand(time(0));
if (rand() % 3 == 0)
{
throw HttpServerException("请求资源不存在", 100, "get");
}
else if (rand() % 4 == 0)
{
throw HttpServerException("权限不足", 101, "post");
}
CacheMgr();
}
int main()
{
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;
}可以看到，如果设计了有关异常的父子类的继承体系，在捕获异常的时候还可以结合多态做出更多的行为。
实际上 C++ 自己也提供了类似的异常库，但是很多公司基本使用都是自己设定的异常库。您可以先简单看下一些 异常库相关文档 即可，大致逻辑也是类似的。
运行时还有很多要补充的...
6.异常意义
6.1.异常优点
- 相比错误码的方式可以清晰准确的展示出错误的各种信息，甚至可以包含堆栈调用的信息，这样可以帮助更好的定位程序的
bug - 返回错误码的传统方式在最大的问题是深度很深，在函数调用链中，深层的函数返回了错误，那么就需要层层返回错误，直到最外层拿到错误
- 很多的第三方库都包含异常（比如：
boost、gtest、gmock等等常用的库，使用它们也需要使用异常） - 部分函数没有返回值，使用异常更好处理（比如：构造函数没有返回值，不方便使用错误码方式处理。
T& operator这样的函数，若pos越界了只能使用异常或者终止程序处理，没办法通过返回值表示错误） OO类语言基本都会使用异常来处理程序运行过程中出现的错误，学习C++的异常后，理解其他语言的异常会容易一些（但机制不完全相同，切记不可照搬，辩证看待）
6.2.异常缺点
- 异常会导致程序的执行流乱跳，导致代码逻辑非常混乱（就类似
goto语句的使用） - 异常只在运行时抛出，这会导致难以跟踪调试代码、分析程序
- 异常会有一些性能的开销，但在现代硬件优化的情况下，基本可以忽略不计
C++不像Java，没有垃圾回收机制，资源需要用户自己管理，有了异常反倒容易导致内存泄漏、死锁等异常等安全问（这个就需要使用RAII还有智能指针等来处理资源的管理问题，但这些的学习成本较高）C++标准库的异常体系定义得不太好，导致各家公司自定义了多种异常体系，非常的混乱，这点不如其他的语言- 如果用户随意抛出异常，外层捕获的设计就会难以捕捉。因此最好保证抛出的异常类型都继承自一个父类，而函数是否抛异常、抛什么样的异常，都使用
func() throw();这样的方式规范化、明确化（但是这点又不是强制性的，有点形同虚设的感觉）
补充：
- 可读性：
try块的范围越大，代码的逻辑结构可能会变得更加复杂和难以理解。较大的try块可能包含多个可能抛出异常的代码片段，使得阅读和理解代码变得更加困难。因此，建议将try块的范围保持在合理的大小，并将其与相关的异常处理逻辑紧密联系起来。- 异常处理的粒度：
try块的范围大小会影响异常处理的粒度。如果try块的范围较大，那么在捕获异常时可能无法确定是哪部分代码引发了异常，从而导致异常处理的粒度较粗。相反，如果try块的范围较小，可以更精确地确定引发异常的代码片段，从而提高异常处理的粒度。- 资源管理：
try块的范围大小还会影响资源的管理方式。如果try块的范围较大，那么在释放资源时可能需要在catch块中手动释放资源，这样会增加代码的复杂度。相反，如果try块的范围较小，可以更容易地使用RAII（资源获取即初始化）技术来管理资源，从而简化资源的释放过程。
更新日志
2025/11/24 07:31
查看所有更新日志