C++异常

2025-12-23 12:30:13

文章摘要

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

@TOC

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

传统的错误处理机制：

终止程序，如assert，缺陷：用户难以接受。如发生内存错误，除0错误时就会终止程序。
返回错误码，缺陷：需要程序员自己去查找对应的错误。如系统的很多库的接口函数都是通过把错误码放到errno中，表示错误、实际中C语言基本都是使用返回错误码的方式处理错误，部分情况下使用终止程序处理非常严重的错误。

C++的异常

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

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

简单的理解就是如果有一个块（代码）抛出一个异常，捕获异常的方法会使用 try 和 catch 关键字。try 块中放置可能抛出异常的代码，try 块中的代码被称为保护代码。如下：

try
{
 // 保护的标识代码，也就是写入你要执行的代码，如果有异常抛出，就会执行catch，否则就不会执行
}catch( ExceptionName e1 )
{
 // catch 块
 //报错后，写入对应的处理方法
}catch( ExceptionName e2 )
{
 // catch 块
}catch( ExceptionName eN )
{
 // catch 块
}

下面写一个简单的代码演示一下：

using namespace std;
int Discion(int a, int b)
{
	if (b == 0)
	{
		//throw "b is zero";
		throw b+200;//throw为抛出异常的关键字,抛出的异常为数字
	}
	else
	{
		return a / b;
	}

catch是一个关键字，捕获的类型跟throw抛出来的类型是一样，如果throw抛出一个int。 catch 要捕捉的就是int 更具体的规则如下：异常的抛出和匹配原则

异常是通过抛出对象而引发的，该对象的类型决定了应该激活哪个catch的处理代码。
被选中的处理代码是调用链中与该对象类型匹配且离抛出异常位置最近的那一个。

int Discion(int a, int b) { if (b == 0) { //throw "b is zero"; throw b+200;//throw为抛出异常的关键字,抛出的异常为数字 } else { return a / b; }

} void Function1() { char arr[] = "ss"; printf("%p\n", arr); throw arr; } void Function() { try { Discion(20, 0); } catch (const char* str)//捕获抛出异常的字符 { printf("%p\n", str); cout << str << endl; } Function1();

简单的理解就是，Function()内有异常捕获，捕获到int，但是Function()内部是没有写对应类型的catch，就会退出function(),跳到main中找到对应的catch中，执行对应的catch语句

在函数调用链中异常栈展开匹配原则
1. 首先检查throw本身是否在try块内部，如果是再查找匹配的catch语句。如果有匹配的，则
调到catch的地方进行处理。
2. 没有匹配的catch则退出当前函数栈，继续在调用函数的栈中进行查找匹配的catch。
3. 如果到达main函数的栈，依旧没有匹配的，则终止程序。上述这个沿着调用链查找匹配的
catch子句的过程称为栈展开。所以实际中我们最后都要加一个catch(...)捕获任意类型的异
常，否则当有异常没捕获，程序就会直接终止。
4. 找到匹配的catch子句并处理以后，会继续沿着catch子句后面继续执行。

抛出异常对象后，会生成一个异常对象的拷贝，因为抛出的异常对象可能是一个临时对象，所以会生成一个拷贝对象，这个拷贝的临时对象会在被catch以后销毁。（这里的处理类似于函数的传值返回）
catch(...)可以捕获任意类型的异常，问题是不知道异常错误是什么。简单的理解就是 ![在这里插入图片描述]这个是最后写的，主要作用就是防止程序某些原因抛出异常没有被捕获，进行捕获任何异常。
实际中抛出和捕获的匹配原则有个例外，并不都是类型完全匹配，可以抛出的派生类对象，使用基类捕获，这个在实际中非常实用，简单的理解就是，很多公司都会自定义自己的异常体系进行规范的异常管理，因为一个项目中如果大家随意抛异常，那么外层的调用者基本就没办法玩了，所以实际中都会定义一套继承的规范体系。这样大家抛出的都是继承的派生类对象，捕获一个基类就可以了。代码如下：

class MyException//异常基类 { public: MyException(const char* arr, int id) :_errmsg(arr) ,_id(id) { } virtual string What() const { return _errmsg; }

protected: string _errmsg; int _id; }; //数据库异常 class SqlExecption : public MyException { public: SqlExecption(const char* arr, int id, const char* sql) :MyException(arr, id) ,_sql(sql) { } virtual string What() const override { string str = "SqlException:"; str += _errmsg; str += "->"; str += _sql; return str; }

抛出派生类的异常，用基类进行捕获，

异常安全

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

void fun()
{
	int* p1 = nullptr;
	int* p2 = nullptr;
	int* p3 = nullptr;
	try 
	{
		p1 = new int[10];
		try
		{
			p2 = new int[20];
			try
			{
				p3 = new int[300000000];
			}
			catch (...)
			{
				delete[] p3;
				p3 = nullptr;
				throw;
			}
		}
		catch (...)
		{
			delete[] p2;
			p2 = nullptr;
			throw;
		}
	}
	catch (...)
	{
		delete[] p1;
		p1 = nullptr;
	}
	delete[] p1;
	delete[] p2;
	delete[] p3;
}

这个就是new开辟空间的捕获形式，这样写看上去很难看，后面可以使用智能指针进行书写

异常规范

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

void Fun1() throw()//不抛出任何异常 { } void Fun2() throw(int, double, float)//会抛出int, double, float其中的一种异常 { } int main() { Fun1(); Fun2();

虽然这个异常规范能让人清楚可以抛出啥异常，但是实际上抛出的异常跟声明不一样一样 ![在这里插入图片描述] 如图，fun2函数虽然写了可能的抛出异常的类型，但是实际上没有抛出异常，但是编译器仅仅只是警告没有报错，所以说，异常规范只是建议，实际抛出的异常还要看作者怎么写上面的C++98的写法，为此C++11进行简化：

// C++11 中新增的noexcept，表示不会抛异常
thread() noexcept;
thread (thread&& x) noexcept;

简单的理解就是，抛异常就不用写异常规范，如果确定不抛异常就加noexcept

C++标准库的异常体系

在c++中也有属于自己的异常标准库

![在这里插入图片描述]![在这里插入图片描述] 其中exception的类是一个所有异常的父类，所以说我们可以捕获这个类就行

int main()
{
	try
	{
		vector<int> arr(10,5);
		//arr[10] = 5;
		arr.reserve(2000000000);
}
catch (const exception&amp; e)
{
	cout &lt;&lt; e.what() &lt;&lt; endl;
}
catch (...)
{
	cout &lt;&lt; &quot;Unkown Exception&quot; &lt;&lt; endl;
}
return 0;

效果如下： ![在这里插入图片描述]

异常的优缺点

优点：

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

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;

代码的意思就是，如果调用ServerStart函数，如果连接错误就会返回一个错误码，跟Linux中的程序异常结束，返回的错误码一样，可以看到ConnnectSql中出错了，先返回ServerStart，ServerStart再返回给main函数，main函数再针对问题处理具体的错误。

如果是异常体系，不管是ConnnectSql还是ServerStart及调用函数出错，都不用检查，因为抛出的异常异常会直接跳到main函数中catch捕获的地方，main函数直接处理错误。

C++异常的缺点：

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

声明：该内容由作者自行发布，观点内容仅供参考，不代表平台立场；如有侵权，请联系平台删除。