当前位置：首页 > news >正文

C++的异常

news 来源：原创 2025/7/3 16:09:04

引入：异常的意义是什么？

①：错误分离
将正常逻辑（try）与错误处理（catch）分离，避免代码被大量 if-else 污染。

②：强制处理
若不捕获异常，程序终止，避免错误被静默忽略（对比返回错误码可能被遗漏检查）。

③：跨函数传播
异常可自动跨多层函数调用栈向上传递，无需逐层检查返回值。

④：类型安全
能抛出任意类型（对象、字符串等），比错误码（固定类型）更灵活。

⑤：资源安全
结合 RAII（如智能指针），确保异常发生时资源自动释放。

一句话：异常是 C++ 中结构化、类型安全、自动化的错误处理机制，替代传统错误码的局限性

一：C和C++处理错误的方式的对比

1：C中的处理错误的方式

①：终止程序（如assert）

例子：

#include <assert.h>
#include <stdio.h>int divide(int a, int b) {assert(b != 0);  // 如果b为0，程序会终止return a / b;
}int main() {printf("Result: %d\n", divide(10, 2));  // 正常工作printf("Result: %d\n", divide(10, 0));  // 程序会在此终止return 0;
}

报错如下：

缺陷：

当除数为0时，程序会突然终止，用户可能看到类似"Assertion failed: b != 0"的错误消息
没有给用户友好的错误处理机会
在生产环境中突然终止程序通常不是好的用户体验

②：返回错误码

例子：

#include <stdio.h>
#include <errno.h>
#include <string.h>int divide(int a, int b, int* result) {if (b == 0) {errno = EDOM;  // 定义域错误return -1;     // 返回错误码}*result = a / b;return 0;          // 返回0表示成功
}int main() {int result;if (divide(10, 0, &result) != 0) {printf("Error occurred: %s\n", strerror(errno));  // 需要查阅errno}else {printf("Result: %d\n", result);}return 0;
}

运行结果：

缺陷：

程序员必须记得检查返回值
需要查阅文档或头文件了解错误码含义
错误处理代码可能使主逻辑变得混乱
像errno这样的全局变量在多线程环境中可能有线程安全问题

总结：

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

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

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

2：C++中处理错误的方式

C++则采取的是用异常来处理错误~

异常是一种处理错误的方式， 当一个函数发现自己无法处理的错误时就可以抛出异常，让函数的

直接或间接的调用者处理这个错误

例子：

double Division(int a, int b)
{// 当b == 0时抛出异常if (b == 0)throw "Division by zero condition!";elsereturn ((double)a / (double)b);
}int main()
{int a = 0;int b = 0;cin >> a >> b;try{Division(a, b);}catch (const char* s){cout << "捕获异常:" << s << endl;}}

当输入的b为0 的时候，打印如下：

往往会加上"捕获异常"，显得更直观，甚至可以加上__LINE__在打印语句中，这样能够直观的知道在哪一行进行了打印异常的操作

__LINE__ 是一个预定义的宏，它的作用是在编译时被替换为当前代码所在的行号

		cout << __LINE__ << "捕获异常:" << s << endl;

打印如下：

389即打印的那一行的行号

其实从这个例子，也能稍微看出来异常使用时的一些语法：

但异常的语法不仅仅如此~

二：异常的语法规则

1：关键字的介绍

· throw: 当问题出现时，程序会抛出一个异常。这是通过使用 throw 关键字来完成的。

· catch: 在您想要处理问题的地方，通过异常处理程序捕获异常 . catch 关键字用于捕获异常，可以有多个catch 进行捕获。

· try: try 块中的代码标识将被激活的特定异常 , 它后面通常跟着一个或多个 catch 块。

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

出异常的代码， try 块中的代码被称为保护代码。使用 try/catch 语句的语法如下所示：

try
{// 可能会抛异常的代码
}catch(  )
{// catch 块
}

2：异常的抛出和匹配原则

1. 异常是通过 抛出对象而引发 的，该 对象的类型 决定了应该激活哪个 catch 的处理代码。

对象：任意类型的实例。

2. 被选中的catch处理代码是调用链中 与该对象类型匹配且离抛出异常位置最近 的那一个。

就近原则

3. 抛出异常对象后，会生成一个异常对象的拷贝，因为抛出的异常对象可能是一个临时对象，所以会生成一个拷贝对象，这个拷贝的临时对象会在被catch 以后销毁。（这里的处理类似于函数的传值返回）

4. catch(...) 可以捕获任意类型的异常，问题则是不知道异常错误是什么。

5. 实际中抛出和捕获的匹配原则有个例外，并不都是类型完全匹配， 可以抛出的派生类对象， 使用基类捕获！这个十分重要

对以上5点逐一举例：

原则1的例子：

double Division(int a, int b)
{// 当b == 0时抛出异常if (b == 0)throw "Division by zero condition!";elsereturn ((double)a / (double)b);
}int main()
{int a = 0;int b = 0;cin >> a >> b;try{Division(a, b);}catch (const char* s){cout << __LINE__ << "捕获异常:" << s << endl;}catch (int s){cout << __LINE__ << "捕获异常:" << s << endl;}catch (double s){cout << __LINE__ << "捕获异常:" << s << endl;}}

运行结果：

解释：

即使我们有多个catch，但还是匹配到的389行的catch中的打印语句，所以对象的类型决定了应该激活哪个catch的处理代码。

原则2的例子：

double Division(int a, int b)
{// 当b == 0时抛出异常if (b == 0)throw "Division by zero condition!";elsereturn ((double)a / (double)b);
}void func(int a, int b)
{try{Division(a, b);}catch (const char* s){cout << __LINE__ << "捕获异常:" << s << endl;cout << "由func内部的catch捕获" << endl;}
}int main()
{int a = 0;int b = 0;cin >> a >> b;try{func(a, b);}catch (const char* s){cout << __LINE__ << "捕获异常:" << s << endl;cout << "由main内部的catch捕获" << endl;}}

运行结果：

解释：

当 Division 抛出异常时，首先由 func 中的 catch 块处理
如果 func 中的 catch 块没有处理异常（比如捕获不同类型的异常）或者选择重新抛出（使用 throw;），那么异常会传递到 main 中的 catch 块

这正体现了"调用链中与该对象类型匹配且离抛出异常位置最近的那一个"的异常处理机制。

原则3的例子：

举例子前需要再理解一下原则3：

3. 抛出异常对象后，会生成一个异常对象的拷贝，因为抛出的异常对象可能是一个临时对象，

所以会生成一个拷贝对象，这个拷贝的临时对象会在被 catch 以后销毁。（这里的处理类似

于函数的传值返回）

说白了就是当你在一个域中抛出了异常对象后，有可能是在域外进行捕获的；就类似与一个函数进行值返回的时候，你在main中接收这个值，该值会触发构造函数，所以同理的，在域外进行异常捕获也会让抛出的异常对象生成一个拷贝对象，才能让域外的catch成功捕获

所以下面代码就是一个自己实现的类(MyException)，当抛出异常的对象是这个类的对象的时候，最起码会触发一次构造函数，这次构造函数就是throw语句去构造对象的，因为先不考虑你抛出的对象在哪个域被捕获，起码你得先有对象，所以第一个构造是throw造成的；现在当你的catch是在域外的时候，就应该是除开最开始的那一次构造，应该还有一次拷贝构造，那我们运行结果会如我们所愿吗？

#include <iostream>
using namespace std;class MyException 
{
public:MyException(const string& msg): message(msg){cout << "构造" << endl;}// 拷贝构造函数MyException(const MyException& other): message(other.message){cout << "拷贝构造" << endl;}private:string message;
};void func1()
{cout << "func1: 准备抛出异常..." << endl;throw MyException("这是一个异常"); // 这里会构造一个临时对象，然后拷贝构造一个新对象
}void func2()
{try{func1();}catch (const MyException& e){ // 这里用引用捕获，避免再次拷贝cout << "func2 捕获异常" << endl;}
}int main() {func2();return 0;
}

运行结果：

Q：为什么跨域异常捕获没有触发拷贝构造？

A：现代C++编译器（特别是C++17及以后版本）会对异常处理进行以下优化：

拷贝省略（Copy Elision）：编译器会直接在被调用的catch块处构造异常对象，跳过中间的拷贝步骤
优化：编译器完全跳过拷贝/或移动，直接在目标位置构造对象

所以，知道原则3就行了，有时候例子也不一定能演示除出来

原则4例子：

#include <iostream>
#include <string>
using namespace std;void testFunction(int type)
{switch (type){case 1:throw 42;                // 抛出int类型case 2:throw 3.14;              // 抛出double类型case 3:throw string("hello");   // 抛出string类型case 4:throw runtime_error("error"); // 抛出标准异常}
}int main()
{for (int i = 1; i <= 4; i++){try{testFunction(i);}catch (...){  // 捕获所有类型的异常cout << "捕获到未知类型异常" << endl;}}
}

运行结果：

解释：

循环进行四个case，所产生的异常，都被main函数中的catch(...)捕获到了，但是也仅仅是捕获到了，不知道捕获的类型，所以无法打出具体的信息；

Q：那catch(...)的意义是什么，你只是捕获到了而已，我也不知道捕获到了什么啊？

A：C++中当有异常没被捕获，程序就会直接终止，所以一般catch(...) 是最后一层保险，任意类型的异常都可以匹配！比如，我们把上述例子的catch(...)换成catch(int x)，这样就会有三个case抛出的异常无法被捕获，就会出现一下报错：

原则5的例子：

体现基类类型可以捕获派生类对象：

#include <iostream>
using namespace std;// 基类
class Base {};// 派生类
class Derived : public Base {};int main() 
{try {throw Derived(); // 抛出派生类对象}catch (Base&) {      // 用基类捕获cout << "成功用基类捕获了派生类对象" << endl;}
}

运行结果：

解释：抛出的是派生类对象，但是可以用基类进行捕获！

最后在五个原则之外呢，还有一个异常栈展开匹配原则：

1. 首先检查 throw 本身是否在 try 块内部，如果是再查找匹配的 catch 语句。如果有匹配的，则调到catch 的地方进行处理。

2. 没有匹配的 catch 则退出当前函数栈，继续在调用函数的栈中进行查找匹配的 catch 。

3. 如果到达 main 函数的栈，依旧没有匹配的，则终止程序 。上述这个沿着调用链查找匹配的

catch 子句的过程称为 栈展开 。所以实际中我们最后都要加一个 catch(...) 捕获任意类型的异

常，否则当有异常没捕获，程序就会直接终止。

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

这不用单独讲，是一个常识性的问题，但是可以提现为什么要有原则4中 catch(...)的存在！

三：异常的使用场景

第三大点是最重要的一点要会多态才能理解！

多态博客：多态的原理 -CSDN博客

1：自定义异常体系

①：字符串前缀

上面说了这么多，好像还是无法提现到异常捕获在哪里会被使用，但其实原则5就是应用的场景！

也就是可以用过基类来捕获派生类的异常！

场景：

一个公司里面，往往会有多个小组，比如开发小组，测试小组....这里就假设有两个小组，现在对于除0错误，开发小组抛出一个string类对象(throw "Division by zero condition!")，而测试小组也抛出一样的对象(throw "Division by zero condition!")，此时当程序员去捕获异常的地方观测的时候，会分不清楚，到底是谁抛出的，那能不能通过字符串前缀即可区分来源呢？

// 开发组代码
void devDivision(int a, int b) {if (b == 0) throw "开发组错误: Division by zero";// ...
}// 测试组代码
void testDivision(int a, int b) {if (b == 0) throw "测试组错误: Division by zero";// ...
}int main()
{// 捕获异常try{devDivision(1, 0);}catch (const char* errMsg) {cout << "捕获到异常: " << errMsg << endl;}return 0;
}

解释：

解决了分不清是哪个组抛出的异常的问题，但C++官方想到的场景远比我们复杂得多，所以我们自己想的办法有缺点：

缺点：
①：无法结构化处理错误
所有错误都是 const char*，无法附加额外信息（如错误码、堆栈跟踪等）。例如，开发组可能还想返回错误发生时的变量值，而测试组想返回测试用例ID，字符串无法优雅扩展。

②：容易拼写错误
如果开发组写 "开发组错误"，测试组写 "测试错误"，风格不统一，维护困难。每个抛出异常的地方，都要手动的加前缀，过于麻烦！无法强制统一接口。新成员可能直接抛 "Error: xxx"，导致团队规范被破坏。

②：基类和派生类发

所以公司里真正运用的是原则5 这一点！！！代码如下：


#include <iostream>
#include <string>
using namespace std;// 基类
class BaseException {
public:BaseException(const string& msg) : message(msg) {}// 虚函数，允许派生类重写virtual string what() const {return message;}// 虚析构函数（重要！）virtual ~BaseException() = default;protected:string message; // 存储错误信息
};// 开发组异常（派生类）
class DevException : public BaseException
{
public:DevException(const string& msg): BaseException("[Dev] " + msg) // 自动加前缀{}string what() const override{return message + " (错误码: 1001)";}
};// 测试组异常（派生类）
class TestException : public BaseException
{
public:TestException(const string& msg): BaseException("[Test] " + msg) // 自动加前缀{}
};// 示例函数
void devFunction(int x)
{if (x < 0)throw DevException("输入不能为负数");
}void testFunction(int x)
{if (x == 0)throw TestException("输入不能为零");
}int main()
{try{devFunction(-1); // 触发开发组异常// testFunction(0); // 触发测试组异常}catch (const BaseException& e){ // 用基类捕获所有派生类异常cout << "捕获到异常: " << e.what() << endl;}return 0;
}

运行结果：

解释：相对与手动加前缀的方法原则5优秀有几个点：

①：不用手动加前缀了，构造函数加一次就可以

②：我们可以有N多个组，新增的组继承基类就行，这样我们捕获的时候，catch中只用无脑写基类的类型就能识别出是哪个组抛出的异常

③：直接通过e.waht()来打印错误的信息，而waht()是一个虚函数，这样我们在不同的组里面，可以分别重写虚函数，打印出自己想打印的信息；比如开发组要要额外打印一个错误码，自己重写虚函数即可，而测试组不想打印额外的信息，直接不用重写虚函数，会自动调用基类的版本。

开发组重写 what() 是因为需要 在基类信息基础上追加内容（错误码）。
而测试组不想在基类的基础上追加内容，所以直接可以不重写虚函数

但是呢，C++早就知道我们自己实现基类，过于的麻烦，它连基类都实现好了，直接用库中的基类就行！

2：标准库异常体系

基类复用库中，简化后的代码：

#include <iostream>
#include <string>
#include <exception>
using namespace std;class DevException : public exception
{
public:DevException(const string& msg): message("[Dev] " + msg + " (错误码: 1001)") {}const char* what() const  override{return message.c_str();}private:string message;
};class TestException : public exception
{
public:TestException(const string& msg): message("[Test] " + msg) {}const char* what() const  override{return message.c_str();}private:string message;
};void devFunction(int x) {if (x < 0) throw DevException("输入不能为负数");
}void testFunction(int x) {if (x == 0) throw TestException("输入不能为零");
}int main() {try {devFunction(-1);// testFunction(0);}catch (const exception& e) {cout << "捕获到异常: " << e.what() << endl;}return 0;
}

运行结果：

解释：复用了库中的基类之后，会简单很多，但是呢也有需要注意的点

①：重写虚函数what的书写方式变了：返回值类型：const char*，也就是返回 C 风格字符串（历史原因，兼容 C 和早期 C++）

②：建议派生类重写what函数的时候，加上noexcept，否则可能产生警告（取决于编译器）

至此，异常的应用场景就讲完了❀~

3：对标准库的补充

标准库异常体系

C++标准库当中的异常也是一个基础体系，其中exception就是各个异常类的基类，我们可以在程序中使用这些标准的异常，它们之间的继承关系如下：

下表是对上面继承体系中出现的每个异常的说明：

说明一下：

exception类的what成员函数和析构函数都定义成了虚函数，方便子类对其进行重写，从而达到多态的效果。
实际中我们也可以去继承exception类来实现自己的异常类，但实际中很多公司都会自己定义一套异常继承体系。
其实看起来这么多我们也要不上大多数这也是为什么会说异常体系定义得不够好，导致大家各自定义自己的异常体系，非常的混乱

四：异常安全

将抛异常导致的安全问题叫做异常安全问题，对于异常安全问题下面给出几点建议：

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

②：析构函数主要完成对象资源的清理，最好不要在析构函数中抛出异常，否则可能导致资源泄露（内存泄露、句柄未关闭等）。

③：C++中异常经常会导致资源泄露的问题，比如在new和delete中抛出异常，导致内存泄露，在lock和unlock之间抛出异常导致死锁，C++经常使用RAII(智能指针)的方式来解决以上问题。

其实③这种问题的本质原因，是因为我们在引入中提到的跨函数传播->异常可自动跨多层函数调用栈向上传递，无需逐层检查返回值。一个好处也会带来了一个坏处~

总结：

①②两点可以自己规避，但③要智能指针来解决，博主在C++专栏下一个博客会讲解

五：异常的重新抛出

异常的重新抛出就是为了解决和四大点中的③小点资源泄露的，但是无法完全解决，所以才需要智能指针，下面一步一步的举例，体现异常的重新抛出的作用以及无奈之处，引出智能指针的存在

有时候单个的catch可能不能完全处理一个异常，在进行一些校正处理以后，希望再交给更外层的调用链函数来处理

1：异常重新抛出的场景

场景：

单个的catch会出错：

void func1()
{throw string("这是一个异常");
}
void func2()
{int* array = new int[10];func1();//do something...delete[] array;
}
int main()
{try{func2();}catch (const string& s){cout << s << endl;}catch (...){cout << "未知异常" << endl;}return 0;
}

解释：

其中func2中通过new操作符申请了一块内存空间，并且在func2最后通过delete对该空间进行了释放，但由于func2中途调用的func1内部抛出了一个异常，这时会直接跳转到main函数中的catch块执行对应的异常处理程序，并且在处理完后继续沿着catch块往后执行。

这时就导致func2中申请的内存块没有得到释放，造成了内存泄露。

所以，这种时候，就需要进行异常的重新抛出来避免了内存泄泄露，来解决问题：

void func2()
{int* array = new int[10];try{func1();//do something...}catch (...){delete[] array;throw; //将捕获到的异常再次重新抛出}delete[] array;
}

解释：

①：func2中的new和delete之间可能还会抛出其他类型的异常，因此在fun2中最好以catch(...)的方式进行捕获，将申请到的内存delete后再通过throw重新抛出。

②：重新抛出异常对象时，throw后面可以不用指明要抛出的异常对象（正好也不知道以catch(...)的方式捕获到的具体是什么异常对象）。

2：重新抛出也无法解决的场景

但是呢会有一些场景，即使是用异常的重新抛出也难以解决，比如：

#include <iostream>
using namespace std;void riskyOperation() {int* ptr1 = new int(100);  // 内存1int* ptr2 = new int(200);  // 内存2int* ptr3 = new int(300);  // 内存3// 模拟后续操作抛出异常throw runtime_error("操作失败");// 正常释放（永远不会执行）delete ptr1;delete ptr2;delete ptr3;
}int main() {try {riskyOperation();} catch (const exception& e) {cerr << "错误: " << e.what() << endl;// 问题：ptr1/ptr2/ptr3 内存泄漏！}
}

此时我们想用异常的重新抛出来解决，会发现，太麻烦了~~~

void riskyOperation() {int* ptr1 = nullptr;int* ptr2 = nullptr;int* ptr3 = nullptr;try {ptr1 = new int(100);ptr2 = new int(200);ptr3 = new int(300);throw runtime_error("操作失败");delete ptr1;delete ptr2;delete ptr3;} catch (...) {// 必须按申请顺序反向释放！delete ptr3;delete ptr2;delete ptr1;throw;  // 重新抛出}
}

缺陷：

需要 严格反向释放（ptr3 → ptr2 → ptr1），否则可能漏掉。
每增加一个 new，就要多写一个 delete，维护成本高。

3：异常规范

异常规范是C++官方在智能指针产生前，看见重新抛出也无法解决的场景，决定进行异常的规范，来避免这种场景，但仍然无法完全避免，所以有了智能指针

为了让函数使用者知道某个函数可能抛出哪些类型的异常，C++标准规定：

在函数的后面接throw(type1, type2, ...)，列出这个函数可能抛掷的所有异常类型。
在函数的后面接throw()或noexcept（C++11），表示该函数不抛异常。
若无异常接口声明，则此函数可以抛掷任何类型的异常。（异常接口声明不是强制的）

//表示func函数可能会抛出A/B/C/D类型的异常
void func() throw(A, B, C, D);
//表示这个函数只会抛出bad_alloc的异常
void* operator new(std::size_t size) throw(std::bad_alloc);
//表示这个函数不会抛出异常
void* operator new(std::size_t size, void* ptr) throw();

虽然C++官方对进行了异常规范，但是不治本，比如：

①：你认为他不会抛异常，但他出现了异常

②：一个函数的确不会抛异常但是它内部调用的函数会抛异常

③：并且异常规范这个东西也不是强制的，只是建议，因为c语言的旧代码没加异常规范，要满足向上兼容

④：你可能会抛异常 abcd 但只写了abc

但是呢都是治标不治本啊，所以有了智能指针达到了治标且治本的效果

六：异常的优缺点

1：异常的优点:

①：异常对象定义好了，相比错误码的方式可以清晰准确的展示出错误的各种信息，甚至可以包含堆栈调用等信息，这样可以帮助更好的定位程序的bug。

②：返回错误码的传统方式有个很大的问题就是，在函数调用链中，深层的函数返回了错误，那么我们得层层返回错误码，最终最外层才能拿到错误。

③：很多的第三方库都会使用异常，比如boost、gtest、gmock等等常用的库，如果我们不用异常就不能很好的发挥这些库的作用。

④：很多测试框架也都使用异常，因此使用异常能更好的使用单元测试等进行白盒的测试。

⑤：部分函数使用异常更好处理，比如T& operator这样的函数，如果pos越界了只能使用异常或者终止程序处理，没办法通过返回值表示错误。

2：异常的缺点

①：异常会导致程序的执行流乱跳，并且非常的混乱，这会导致我们跟踪调试以及分析程序时比较困难。

②：异常会有一些性能的开销，当然在现代硬件速度很快的情况下，这个影响基本忽略不计。

③：C++没有垃圾回收机制，资源需要自己管理。有了异常非常容易导致内存泄露、死锁等异常安全问题。这个需要使用RAII来处理资源的管理问题，学习成本比较高。

④：C++标准库的异常体系定义得不够好，导致大家各自定义自己的异常体系，非常的混乱。

⑤：异常尽量规范使用，否则后果不堪设想，随意抛异常，也会让外层捕获的用户苦不堪言。

⑥：异常接口声明不是强制的，对于没有声明异常类型的函数，无法预知该函数是否会抛出异常。

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

引入：异常的意义是什么？

一：C和C++处理错误的方式的对比

1：C中的处理错误的方式

①：终止程序（如assert）

②：返回错误码

2：C++中处理错误的方式

二：异常的语法规则

1：关键字的介绍

2：异常的抛出和匹配原则

三：异常的使用场景

1：自定义异常体系

①：字符串前缀

②：基类和派生类发

2：标准库异常体系

3：对标准库的补充

四：异常安全

五：异常的重新抛出

1：异常重新抛出的场景

2：重新抛出也无法解决的场景

3：异常规范

六：异常的优缺点

1：异常的优点:

2：异常的缺点

相关文章：