C++之异常

一、异常的概念及其使用

1. 异常的概念

*异常处理机制允许程序中独立开发的部分能够在运行时就出现的问题进行通信并做出相应的处理，异常使我们能够将问题的检查与解决问题的过程分开，程序的一部分负责检测问题的出现，然后解决问题的任务传递给程序的另一部分，检测环节无须知道问题的处理模块的所有细节。

*C语言主要通过错误码的形式处理错误，错误码的本质就是对错误信息进行分类编号，拿到错误码以后去查询错误信息，比较麻烦。异常时抛出一个对象，这个对象可以函数更全面的各种信息。

2.异常的抛出与捕获

*程序出现问题时，我们通过抛出（throw）一个对象来引发一个异常，该对象的类型以及当前的调用链决定了应该有哪一个catch的处理代码来处理这个异常。

*被选中的处理代码是调用链中与该对象类型匹配且离抛出异常位置最近的那一个。根据抛出对象的类型和内容，程序的抛出异常部分告诉异常处理部分到底发生什么错误。

*当throw执行时，throw后面的语句将不再执行。程序的执行从throw位置直接跳转到与之匹配的catch模块，catch可能是同一个函数中的局部catch，也可能是调用链中另一个函数中的catch。控制权直接从throw调转到catch上。还有 1、沿着调用链的函数可能提早退出。2、一旦程序开始执行异常处理程序，沿着调用链创建的对象都将被销毁。

*抛出异常对象后，会生成一个异常对象的拷贝，因为抛出的异常对象可能是一个局部对象，所以会生成一个拷贝对象。这个拷贝对象会在catch子句结束后销毁。（类似于函数传值返回）。

3.栈展开

*抛出异常后，程序暂停当前函数的执行，开始寻找与之匹配的catch子句，首先检查throw本身是否在try块内部，如果在则查找匹配catch语句，如果有匹配的，则跳转到catch的地方进行处理。

*如果当前函数中没有try/catch语句，或者有try/catch语句但是类型不匹配，则退出当前函数。继续在外层调用函数链中查找，上述查找的catch过程被称为栈展开。

*如果到达main函数，依然没有找到匹配的catch子句，程序就会调用标准库的terminate函数终止程序。

*如果找到匹配的catch子句后，catch子句代码会继续执行。

double Divide(int a, int b) {
	try
	{
		if (b == 0) {
			string s("Divide by zero condition!");
            //抛出给最近的能接受s的catch
			throw s;
		}
		else {
			return (double)a / (double)b;
		}
	}
	catch (int s) {
        //因为catch捕获的是int而不是string所以这个不匹配
		cout << s << endl;
	}
	return 0;
}
void Func() {
	int a, b;
	cin >> a >> b;
	try {
		cout << Divide(a, b) << endl;
	}
    //这个是const指针，与string不匹配
	catch (const char* errmsg) {
		cout << errmsg << endl;
	}
	cout << __FUNCTION__ << ":" << __LINE__ << "行执行" << endl;
}
int main() {
	while (1) {
		try {
			Func();
		}
        //匹配
		catch (const string& errmsg) {
			cout<<errmsg<<endl;
		}
	}
	return 0;
}

4.查找匹配的处理代码

*一般情况下抛出对象和catch是类型完全匹配的，如果有多个类型匹配的，遵循就近原则。

*但是也有例外，允许从非常量向常量类型转换，也就是权限缩小；允许数组转化成指向数组元素类型的指针，函数被转化成指向函数的指针；允许从派生类向基类类型的转换，这个点非常实用，继承体系基本都是用这个方式来设计的。

*如果到main函数时，异常仍然没有被匹配就会终止程序，不是发生严重错误的情况，我们不希望程序终止的，所以一般main函数后面我们都会使用catch（...），它可以捕获任意类型的异常，但是不知道异常的类型是什么。

//定义异常基类
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:
	int _id;
	string _errmsg;
};
//根据各个部分的差异性定义子类来重写父类，或者增加子类特有的属性
class SqlExcetion :public Exception {
public:
	SqlExcetion(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 HttpException : public Exception
{
public:
	HttpException(const string& errmsg, int id, const string& type)
		:Exception(errmsg, id)
		, _type(type)
	{
	}
	virtual string what() const
	{
		string str = "HttpException:";
		str += _type;
		str += ":";
		str += _errmsg;
		return str;
	}
private:
	const string _type;
};
/调用各自的函数，抛出子类异常给父类接受，形成多态
void SQLMgr() {
	if (rand() % 7 == 0){
		throw SqlExcetion("权限不足", 100, "select * from name = '张三'");
	}
	else {
		cout << "SQLMgr 调用成功" << endl;
	}
}
void CacheMgr() {
	if (rand() % 5 == 0) {
		throw CacheException("权限不足", 100);
	}
	else if (rand()% 6 == 0) {
		throw CacheException("数据不存在", 101);
	}
	else {
		cout << "CacheMgr 调用成功" << endl;
	}
	SQLMgr();
}
void HttpServer()
{
	if (rand() % 3 == 0)
	{
		throw HttpException("请求资源不存在", 100, "get");
	}
	else if (rand() % 4 == 0)
	{
		throw HttpException("权限不足", 101, "post");
	}
	else
	{
		cout << "HttpServer调用成功" << endl;
	}
	CacheMgr();
}
int main() {
	srand(time(0));
	while (1) {
		this_thread::sleep_for(chrono::seconds(3));
		try {
			HttpServer();
		}
		catch(const Exception& e){
			cout << e.what() << endl;
		}
		catch (...) {
			cout << "Unknow Exception" << endl;
		}
		cout << endl;
		cout << endl;
	}
}

5.异常重新抛出

有时候catch到一个异常对象后，需要对错误进行分类，其中某种异常错误需要进行特殊的处理，其他错误则重新抛出异常给外层调用链处理。捕获异常后需要重新抛出，直接throw；就可以把捕获的对象直接抛出。

// 下⾯程序模拟展⽰了聊天时发送消息，发送失败补货异常，但是可能在 
// 电梯地下室等场景⼿机信号不好，则需要多次尝试，如果多次尝试都发 
// 送不出去，则就需要捕获异常再重新抛出，其次如果不是⽹络差导致的 
// 错误，捕获后也要重新抛出。 
void _SeedMsg(const string& s)
{
	if (rand() % 2 == 0)
	{
		throw HttpException("⽹络不稳定，发送失败", 102, "put");
	}
	else if (rand() % 7 == 0)
	{
		throw HttpException("你已经不是对象的好友，发送失败", 103, "put");
	}
	else
	{
		cout << "发送成功" << endl;
	}
}
void sendMsg(const string& s) {
	for (size_t i = 0; i < 4; i++) {
		try {
			_SeedMsg(s);
			break;
		}
		catch (const Exception& e) {
			if (e.getid() == 102) {
				if (i == 3)
					throw;
				cout << "开始第：" << i + 1 << "次重试" << endl;
			}
			else {
				throw;
			}

		}
	}
}
int main() {
	srand(time(0));
	string s;
	while (cin>>s) {
		try {
			sendMsg(s);
		}
		catch (const Exception& e) {
			cout << e.what() << endl << endl;
		}
		catch (...) {
			cout << "Unkonw errmsg" << endl << endl;
		}
	}
}

6.异常安全问题

*异常抛出后，后面的代码就不再执行了，前面申请了资源，后面进行释放，但是中间可能会抛出异常就会直接跳到catch，导致有资源没有释放，这里就引发了资源泄露，产生安全性问题。中间我们需要捕获异常，释放资源后再抛出。

*其次析构函数中，如果有抛出异常也会谨慎处理，比如析构函数要释放10个资源，但第5个资源释放时抛出异常，则也需要捕获处理，否则后面的5个资源就没释放，也会造成资源泄露。

7. 异常规范

*对于用户和编辑器而言，预先知道某个程序不会出异常大有裨益，知道某个函数是否会抛出异常有助于简化调用函数的代码。

*C++98中函数后面接throw()表示函数不抛异常，函数列表后面加throw(type1，type2......)表示可能会抛出的多种异常，用逗号分隔。

*C++11进行简化，函数参数列表后面加noexcept表示不会抛出异常，如果啥也不加则表示可能会抛出异常

*编译器并不会检测noexcept，也就是说如果一个函数用noexcept修饰，也可能抛出异常，编译器会顺利编译通过，但声明了noexcept后抛出异常，程序会调用terminate终止程序。

*noexcept（expression）还可以作为一个运算符去检测一个表达式是否会抛出异常。

int main()
{
     try
     {
         int len, time;
         cin >> len >> time;
         cout << Divide(len, time) << endl;
     }
     catch (const char* errmsg)
     {
         cout << errmsg << endl;
     }
     catch (...)
     {
         cout << "Unkown Exception" << endl;
     }
 
     int i = 0;
//无论是否会抛出异常，只要有可能，就会为false
     cout << noexcept(Divide(1,2)) << endl;
     cout << noexcept(Divide(1,0)) << endl;
     cout << noexcept(++i) << endl;
     return 0;
}

二、标准库的异常

*https://legacy.cplusplus.com/reference/exception/exception/

*C++标准库也定义了一套自己的一套异常继承体系库，基类为exception，我们在日常写程序的时候在主程序里去捕获exception就可以了，如果要获取异常信息，就调用what函数，what函数是一个虚函数，在派生类中可以重写。