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

【C++】异常处理

java 2025/7/14 17:35:16

📚 博主的专栏

🐧 Linux | 🖥️ C++ | 📊 数据结构 | 💡C++ 算法 | 🌐 C 语言

上篇文章：C++11线程库的使用

下篇文章：C++11智能指针

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

C++异常概念

异常的使用

异常的抛出和捕获

异常的抛出和捕获异常的抛出和匹配原则

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

异常的重新抛出

异常安全

异常规范

自定义异常体系

数据库模块异常

缓存层的错误：

网络层的错误：

模拟：

C++标准库的异常体系

C++异常的优缺点

C++异常的优点：

C++异常的缺点：

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

传统的错误处理机制：

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

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

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

C++异常概念

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

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

如果有一个块抛出一个异常，捕获异常的方法会使用 try 和 catch 关键字。try 块中放置可能抛出异常的代码，try 块中的代码被称为保护代码。使用 try/catch 语句的语法如下所示：

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

示例程序：
#include<iostream>
using namespace std;double Division(int a, int b)
{// 当b == 0时抛出异常if (b == 0)throw "Division by zero condition!";elsereturn ((double)a / (double)b);
}
void Func()
{int len, time;cin >> len >> time;cout << Division(len, time) << endl;
}
int main()
{try {Func();}catch (const char* errmsg){cout << errmsg << endl;}catch (...) {cout << "unkown exception" << endl;}return 0;
}
当我们输入的数字能做正常的除法运算的时候，执行完程序之后会跳过try..catch..直接到return 0;当我输入不符合要求的数字时，例如我输入的分母为0，在执行到Division后，就会进入到异常处理catch块，输出我们throw的错误errmsg

异常的使用

异常的抛出和捕获

异常的抛出和捕获异常的抛出和匹配原则

1. 异常是通过抛出对象而引发的，该对象的类型决定了应该激活哪个catch的处理代码。
2. 被选中的处理代码是调用链中与该对象类型匹配且离抛出异常位置最近的那一个。
3. 抛出异常对象后，会生成一个异常对象的拷贝，因为抛出的异常对象可能是一个局部对象，所以会生成一个拷贝对象，这个拷贝的临时对象会在被catch以后销毁。（这里的处理类似于函数的传值返回）

例如我们在这里，所抛出的str是str吗？不是，抛出的是str的拷贝，而原本的str出作用域就被销毁了。但是在C++11下，会将str识别为右值，这里会直接走移动构造，因此这里拷贝的代价是很低的。

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

当抛出的异常没有匹配的类型，就使用这个，相当于最后一张底牌，让程序不会终止，相当于弹窗。

一般我们程序都是这样设计的：程序都是在循环当中，当触发了flag才会退出

5. 实际中抛出和捕获的匹配原则有个例外，并不都是类型完全匹配，可以抛出的派生类对象，使用基类捕获，这个在实际中非常实用，我们后面会详细讲解这个。

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

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

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

3. 如果到达main函数的栈，依旧没有匹配的，则终止程序(所以一定要捕获异常，并且在main函数的栈以及之前一定要有匹配的类型)。上述这个沿着调用链查找匹配的catch子句的过程称为栈展开。所以实际中我们最后都要加一个catch(...)捕获任意类型的异常，否则当有异常没捕获，程序就会直接终止。

刚才所举得例子，也可以在Func中进行捕获，但是一般异常的捕获都是写在外层的（main）

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

就像这里，打印出errmsg之后，继续执行下一条cout语句。

匹配的过程：

异常的重新抛出

有可能单个的catch不能完全处理一个异常，在进行一些校正处理以后，希望再交给更外层的调用链函数来处理，catch则可以通过重新抛出将异常传递给更上层的函数进行处理。

double Division(int a, int b)
{// 当b == 0时抛出异常if (b == 0){throw "Division by zero condition!";}return (double)a / (double)b;
}
void Func()
{// 这里可以看到如果发生除0错误抛出异常，另外下面的array没有得到释放。// 所以这里捕获异常后并不处理异常，异常还是交给外面处理，这里捕获了再// 重新抛出去。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;//捕获什么抛出什么}// ...cout << "delete []" << array << endl;delete[] array;
}
int main()
{try{Func();}catch (const char* errmsg){cout << errmsg << endl;}return 0;
}

但是实际情况可能更加的复杂：当我们new两个指针

void Func()
{int* p1 = new int[10];int* p2 = nullptr;try{p2 = new int[20]; 如果p2没new成功，就会被捕获去释放p1try{int len, time;cin >> len >> time;cout << Division(len, time) << endl; // throw}catch (...){delete[] p1;cout << "delete:" << p1 << endl;delete[] p2;cout << "delete:" << p2 << endl;throw;  // 捕获什么抛出什么}}catch (...){delete[] p1;cout << "delete:" << p1 << endl;throw;}delete[] p1;cout << "delete:" << p1 << endl;delete[] p2;cout << "delete:" << p2 << endl;
}

除了Division可能会抛异常，new也有可能会抛异常。如果p2，new失败了就需要释放p1，，因此，Division出问题就会将p1、p2一起释放，我们还需要单独try catch，后续会用智能指针。

异常安全

构造函数完成对象的构造和初始化，最好不要在构造函数中抛出异常，否则可能导致对象不完整或没有完全初始化
析构函数主要完成资源的清理，最好不要在析构函数内抛出异常，否则可能导致资源泄漏(内存泄漏、句柄未关闭等)
C++中异常经常会导致资源泄漏的问题，比如在new和delete中抛出了异常，导致内存泄漏，在lock和unlock之间抛出了异常导致死锁，C++经常使用RAII来解决以上问题，关于RAII我们智能指针这篇博客再讲解。

异常规范

// 这里表示这个函数会抛出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;

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

自定义异常体系

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

首先有这样一个基类Exception：有两个成员变量：错误信息、错误id。

// 服务器开发中通常使用的异常继承体系
class Exception
{
public:Exception(const string& errmsg, int id):_errmsg(errmsg), _id(id){}virtual string what() const{return _errmsg;}
protected:string _errmsg;int _id;
};

每个层都有单独的错误信息需要加进来，使用继承：

数据库模块异常

继承exception，添加成员变量，记录错误的sql语句

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 = '张三'");}else{cout << "执行sql成功" << endl;}
}

缓存层：

void CacheMgr()
{srand(time(0));if (rand() % 5 == 0){throw CacheException("权限不足", 100);}else if (rand() % 6 == 0){throw CacheException("数据不存在", 101);}else{cout << "Cache获取成功" << endl;}SQLMgr();//缓存层没问题，调用数据库层
}

网络层：

void HttpServer()
{// ...srand(time(0));if (rand() % 3 == 0){throw HttpServerException("请求资源不存在", 100, "get");}else if (rand() % 4 == 0){throw HttpServerException("权限不足", 101, "post");}else{cout << "Http调用成功" << endl;}CacheMgr(); //网络层没问题，调用缓存层
}

启动服务：

网络这部分出错之后，继续监听，等待链接、等待请求，在抛出异常的时候，只需要抛出基类的派生类，这是符合匹配类型的，就不会报错出问题。不匹配的时候就使用catch(...)可以捕获任意类型的异常。在这里还使用了多态，抛出的都是exception的派生类，调用what()，满足多态的两个条件：

1.虚函数的重写，what()的重写
2.父类或基类的指针、引用去调用

因此在运行起来的时候就会去指向虚表里的函数地址，指向谁调用谁的what（）
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++标准库的异常体系

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

说明：实际中我们可以可以去继承exception类实现自己的异常类。但是实际中很多公司像上面一样自己定义一套异常继承体系。因为C++标准库设计的不够好用

因此在捕获异常的时候还可以添加上C++标准库提空的exception，出现new失败，访问stl失败就能在这里抛出异常

C++异常的优缺点

C++异常的优点：

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

2. 返回错误码的传统方式有个很大的问题就是，在函数调用链中，深层的函数返回了错误，那么我们得层层返回错误，最外层才能拿到错误，具体看下面的详细解释。

（异常可以一步到位，直接跳到处理错误的地方）

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

4. 部分函数使用异常更好处理，比如构造函数没有返回值，不方便使用错误码方式处理。比如T& operator这样的函数，如果pos越界了只能使用异常或者终止程序处理，没办法通过返回值表示错误。就像这里，不可能去返回一个T对象吧，因此抛异常能很好地解决问题。

C++异常的缺点：

1. 异常会导致程序的执行流乱跳，并且非常的混乱，并且是运行时出错抛异常就会乱跳。这会导致我们跟踪调试时以及分析程序时，比较困难。

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

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

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

5. 异常尽量规范使用，否则后果不堪设想，随意抛异常，外层捕获的用户苦不堪言。所以异常规范有两点：一、抛出异常类型都继承自一个基类。二、函数是否抛异常、抛什么异常，都使用 func（） throw();的方式规范化。

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

异常的其他学习，还是要在项目实践中深刻体会，在以后的博客文章会讲解一些项目。到时候我们再一起深入学习吧！！！

结语：

随着这篇关于题目解析的博客接近尾声，我衷心希望我所分享的内容能为你带来一些启发和帮助。学习和理解的过程往往充满挑战，但正是这些挑战让我们不断成长和进步。我在准备这篇文章时，也深刻体会到了学习与分享的乐趣。

在此，我要特别感谢每一位阅读到这里的你。是你的关注和支持，给予了我持续写作和分享的动力。我深知，无论我在某个领域有多少见解，都离不开大家的鼓励与指正。因此，如果你在阅读过程中有任何疑问、建议或是发现了文章中的不足之处，都欢迎你慷慨赐教。

你的每一条反馈都是我前进路上的宝贵财富。同时，我也非常期待能够得到你的点赞、收藏，关注这将是对我莫大的支持和鼓励。当然，我更期待的是能够持续为你带来有价值的内容。

查看全文

http://www.xdnf.cn/news/805.html