c++ - 第20节 - 异常

随风张幔

已于 2023-01-09 17:03:34 修改

阅读量462

点赞数

分类专栏： c++ 文章标签： c++ 开发语言

于 2023-01-08 17:40:47 首次发布

本文链接：https://blog.csdn.net/qq_45113223/article/details/128602290

版权

c++ 专栏收录该内容

26 篇文章 4 订阅

订阅专栏

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

传统的错误处理机制：

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

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

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

2.C++异常概念

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

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

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

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

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

3.异常的使用

3.1.异常的抛出和捕获

异常的抛出和匹配原则：

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

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

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

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

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

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

1. 首先检查throw本身是否在try块内部，如果在try块内部再查找匹配的catch语句。如果有匹配的，则调到catch的地方进行处理。没有匹配的catch则退出当前函数栈，继续在调用函数的栈中进行查找匹配的catch。如果到达main函数的栈，依旧没有匹配的，则终止程序。

上述这个沿着调用链查找匹配的catch子句的过程称为栈展开。所以实际中我们最后都要加一个catch(...)捕获任意类型的异常，否则当有异常没捕获，程序就会直接终止。

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

3.catch语句一定是从throw语句跳进来执行的，正常从上往下按顺序执行语句，如果try中没有异常抛出则会忽视catch语句。
double Division(int a, int b)
{
	// 当b == 0时抛出异常
	if (b == 0)
		throw "Division by zero condition!";
	else
		return ((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;
}

下面我们用抛异常的知识写了一个概率函数Probability，代码及运行结果如下所示。

3.2.异常的重新抛出

如下图所示的代码，在Func函数中先new一块空间，然后调用Division函数，Division函数如果发生除以0错误抛出异常，则直接会跳到主函数catch捕获异常部分，然后从主函数catch捕获异常部分开始往后执行代码。因为没有执行Func函数的delete空间释放代码所以造成空间泄漏。这就是一个异常安全问题。
double Division(int a, int b)
{
	// 当b == 0时抛出异常
	if (b == 0)
	{
		throw "Division by zero condition!";
	}
	return (double)a / (double)b;
}

void Func()
{
	int* array = new int[10];

	int len, time;
	cin >> len >> time;
	cout << Division(len, time) << endl;

	cout << "delete []" << array << endl;
	delete[] array;
}

int main()
{
	try
	{
		Func();
	}
	catch (const char* errmsg)
	{
		cout << errmsg << endl;
	}

	return 0;
}
为了解决上面的异常安全问题，func函数部分的代码应该进行优化，如下图所示，使用catch(...)在func函数中先捕获异常，这里捕获异常只是为了进行空间释放，然后再throw抛出该异常在外面主函数中捕获解决。

这里func函数中增加try 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;
}
注：只写一个throw的功能是捕获什么抛什么。

3.3.异常安全

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

$\bullet$ 析构函数主要完成资源的清理，最好不要在析构函数内抛出异常，否则可能导致资源泄漏(内存泄漏、句柄未关闭等)

$\bullet$ C++中异常经常会导致资源泄漏的问题，比如在new和delete中抛出了异常，导致内存泄漏，在lock和unlock之间抛出了异常导致死锁，C++经常使用RAII来解决以上问题，关于RAII我们智能指针这节进行讲解。

3.4.异常规范

1. 异常规格说明的目的是为了让函数使用者知道该函数可能抛出的异常有哪些。可以在函数的后面接throw(类型)，列出这个函数可能抛掷的所有异常类型。

2. 函数的后面接throw()，表示函数不抛异常。

3. 若无异常接口声明，则此函数可以抛掷任何类型的异常。
// 这里表示这个函数会抛出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;
注：c++98期望每个人在写函数时声明清楚是否抛异常，抛什么异常，这里不是必须要写，大家基本都不遵守。c++11在支持c++98的基础上增加了noexcept以简化这块的规则，如果函数不抛异常则在函数的后面加一个noexcept，如果函数抛异常则函数后面不写noexcept。

4.自定义异常体系

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

4.1.C++标准库的异常体系介绍

STL库中就使用了一套自定义异常体系，STL库中定义了基类exception，基类exception的派生类如下图一所示，其中我们常用的有派生类bad_alloc和out_of_range。

之前我们学过的vector、string等容器如果使用中出现错误则会抛异常，这里抛异常的类型就是out_of_range自定义类型，如下图二所示。

之前我们学过的operator new和operator new[]函数功能主要是调用malloc函数开空间，如果开辟空间失败则抛异常，这里抛异常的类型就是bad_alloc自定义类型，如下图三所示。因此如下图四所示的例子，使用new开空间后，我们应该catch捕获bad_alloc类型的异常。这里因为bad_alloc是exception的派生类，因此使用new开空间后，我们也可以catch捕获exception类型的异常。

如下图一二所示，使用new函数开空间，分别catch捕获bad_alloc类型的异常和exception类型的异常。exception里面有一个what函数，返回字符序列，其用于获取字符串标识异常，如下图三所示。因为bad_alloc继承了exception，所以bad_alloc类型的对象也可以使用what函数。

4.2.公司通常使用的异常继承体系

下面所示的代码展示了服务器开发中通常使用的异常继承体系。

我们定义了基类的虚函数Exception，基类的Exception中有两个成员变量string类型的_errmsg来描述错误信息和int类型的_id来记录错误编码，Exception里面what函数的功能是返回错误信息，Exception里面getid函数的功能是返回错误编码。

数据库组定义数据库的SqlException继承基类Exception，在派生类SqlException中有继承Exception的_errmsg和_id成员变量，还有自己的sql成员变量，其功能是记录错误的sql语句。SqlException里面的what函数进行了虚函数重写，其功能是返回错误信息和错误的sql语句。

缓存组定义缓存的CacheException继承基类Exception，在派生类CacheException中有继承Exception的_errmsg和_id成员变量。SqlException里面的what函数进行了虚函数重写，其功能是返回错误信息。

网络协议组定义数据库的HttpServerException继承基类Exception，在派生类HttpServerException中有继承Exception的_errmsg和_id成员变量，还有自己的_type成员变量，其功能是记录错误的类型。SqlException里面的what函数进行了虚函数重写，其功能是返回错误信息和错误的类型。

在各个相关组代码实现部分如果要抛异常，就抛继承Exception的各组对应派生类的异常。具体各个相关组代码实现部分我们使用概率进行模拟。

在网络协议组HttpServer代码中如果要抛异常则直接跳到主函数的捕获catch部分代码然后继续沿着catch部分的后面代码继续执行，如果不抛异常则输出Http success，然后执行缓存组CacheMgr代码。缓存组CacheMgr代码和后面的数据库组SQLMgr代码执行情况与网络协议组HttpServer代码相同。

主函数中的捕获catch部分，我们捕获的类型是Exception&即基类的引用，这里满足多态的两个条件，第一个条件使用父类的指针或引用接收，我们使用Exception&即基类的引用接收，第二个条件调用的是重写的虚函数，我们调用的是what函数而what函数在派生类中被重写。多态调用指向谁调用谁，抛的是派生类对象则调用的是派生类重写的what函数。
namespace bit
{
	// 服务器开发中通常使用的异常继承体系
	class Exception
	{
	public:
		Exception(const string& errmsg, int id)
			:_errmsg(errmsg)
			, _id(id)
		{}

		virtual string what() const
		{
			return _errmsg;
		}

		int getid() const
		{
			return _id;
		}

	protected:
		string _errmsg;  // 描述错误信息
		int _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()
	{
		if (rand() < RAND_MAX / 10)
		{
			throw SqlException("权限不足", 100, "select * from name = '张三'");
		}
		else
		{
			cout << "Sql success" << endl;
		}
	}

	void CacheMgr()
	{
		if (rand() < RAND_MAX / 10)
		{
			throw CacheException("权限不足", 100);
		}
		else if (rand() < RAND_MAX / 4)
		{
			throw CacheException("数据不存在", 101);
		}
		else
		{
			cout << "Cache success" << endl;
		}

		SQLMgr();
	}

	void HttpServer()
	{
		if (rand() < RAND_MAX / 10)
		{
			throw HttpServerException("请求资源不存在", 404, "get");
		}
		else if (rand() < RAND_MAX / 10)
		{
			throw HttpServerException("权限不足", 501, "post");
		}
		else
		{
			cout << "Http success" << endl;
		}

		CacheMgr();
	}

	void SeedMsg(const string& str)
	{
		if (rand() < RAND_MAX - 10000)
		{
			throw HttpServerException("SeedMsg::网络错误", 2, "put");
		}
		else if (rand() < RAND_MAX / 10)
		{
			throw HttpServerException("SeedMsg::你已经不是对方好友", 1, "post");
		}
		else
		{
			cout << "消息发送成功！->" << str << endl;
		}
	}
}

int main()
{
	srand(time(0));

	while (1)
	{
		::Sleep(1000);

		try
		{
			bit::HttpServer();
		}
		catch (const bit::Exception& e) // 这里捕获父类对象就可以
		{
			// 多态
			cout << e.what() << endl;
		}
		catch (const std::exception& e) // 这里捕获父类对象就可以
		{
			// 多态
			cout << e.what() << endl;
		}
		catch (...)
		{
			cout << "Unkown Exception" << endl;
		}
	}

	return 0;
}
注：
1.Sleep(1000)是在模拟软件程序或服务器长期运行的状态。

2.异常继承体系，需要catch(...)捕获未知异常，如果没有catch(...)捕获未知异常，要是出现了未知的异常那么软件程序或服务器的运行会直接终止，会造成大量经济损失。

3.异常继承体系，不仅要catch捕获体系中基类的异常，还要捕获STL库异常继承体系中基类exception的异常，因为代码中或多或少会用到STL标准库中的容器或new函数等，它们抛出的异常需要通过exception类型catch捕获。

在下面的代码中，SeedMsg函数负责处理输入的消息，发送消息有三种情况，消息发送成功、对方不是好友发送失败、网络错误，如果是对方不是好友发送失败和网络错误的情况则抛出不同错误码的HttpServerException异常。主函数部分如果SeedMsg函数消息发送成功则结束，如果抛出异常则catch捕获异常，如果异常是网络错误则重复发送（最多重试10次），如果异常是对方不是好友发送失败则再次抛出异常，由外层的catch捕获，外层的catch内部调用what函数打印异常。

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

		virtual string what() const
		{
			return _errmsg;
		}

		int getid() const
		{
			return _id;
		}

	protected:
		string _errmsg;  // 描述错误信息
		int _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()
	{
		if (rand() < RAND_MAX / 10)
		{
			throw SqlException("权限不足", 100, "select * from name = '张三'");
		}
		else
		{
			cout << "Sql success" << endl;
		}
	}

	void CacheMgr()
	{
		if (rand() < RAND_MAX / 10)
		{
			throw CacheException("权限不足", 100);
		}
		else if (rand() < RAND_MAX / 4)
		{
			throw CacheException("数据不存在", 101);
		}
		else
		{
			cout << "Cache success" << endl;
		}

		SQLMgr();
	}

	void HttpServer()
	{
		if (rand() < RAND_MAX / 10)
		{
			throw HttpServerException("请求资源不存在", 404, "get");
		}
		else if (rand() < RAND_MAX / 10)
		{
			throw HttpServerException("权限不足", 501, "post");
		}
		else
		{
			cout << "Http success" << endl;
		}

		CacheMgr();
	}

	void SeedMsg(const string& str)
	{
		if (rand() < RAND_MAX - 10000)
		{
			throw HttpServerException("SeedMsg::网络错误", 2, "put");
		}
		else if (rand() < RAND_MAX / 10)
		{
			throw HttpServerException("SeedMsg::你已经不是对方好友", 1, "post");
		}
		else
		{
			cout << "消息发送成功！->" << str << endl;
		}
	}
}

int main()
{
	srand(time(0));

	while (1)
	{
		::Sleep(1000);

		try
		{
			//bit::HttpServer();

			// 发送出现网络错误，要求重试10次
			// 权限错误就直接报错 -- 17:20继续
			for (size_t i = 0; i < 10; ++i)
			{
				try
				{
					bit::SeedMsg("你好啊！今晚一起看电影怎么样？");
					break;
				}
				catch (const bit::Exception& e)
				{
					if (e.getid() == 2) //异常编码的价值，针对某个错误进行特殊处理
					{
						cout << "网络错误，重试发消息第" << i << "次" << endl;
						continue;
					}
					else //其他错误(这里只有权限错误)
					{
						throw e;	//异常重新抛出 
					}
				}
			}
		}
		catch (const bit::Exception& e) // 这里捕获父类对象就可以
		{
			// 多态
			cout << e.what() << endl;
		}
		catch (const std::exception& e) // 这里捕获父类对象就可以
		{
			// 多态
			cout << e.what() << endl;
		}
		catch (...)
		{
			cout << "Unkown Exception" << endl;
		}
	}

	return 0;
}

5.异常的优缺点

C++异常的优点：

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

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

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

4.部分函数使用异常更好处理，比如构造函数没有返回值，不方便使用错误码方式处理。比如T& operator[](size_t pos)这样的函数，如果pos越界了只能使用异常或者终止程序处理，没办法通过返回值表示错误。

C++异常的缺点：

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

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

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

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

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

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

随风张幔

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
打赏
0
评论
c++ - 第20节 - 异常

没有匹配的catch则退出当前函数栈，继续在调用函数的栈中进行查找匹配的catch。3. 抛出异常对象后，会生成一个异常对象的拷贝，因为抛出的异常对象可能是一个临时对象，所以会生成一个拷贝对象，这个拷贝的临时对象会在被catch以后销毁。5. 实际中抛出和捕获的匹配原则有个例外，并不都是类型完全匹配，可以抛出的派生类对象，使用基类捕获，这个在实际中非常实用，我们后面会详细讲解这个。，缺陷：需要程序员自己去查找对应的错误。1. 异常是通过抛出对象而引发的，该对象的类型决定了应该激活哪个catch的处理代码。
复制链接

扫一扫