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

C++异常的使用

article 2025/2/24 16:22:12

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++智能指针》会使用智能指针优化这一过程。

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();这样的方式规范化、明确化（但是这点又不是强制性的，有点形同虚设的感觉）

查看全文

http://www.kler.cn/a/158192.html