【C++】异常

2025-01-17 16:29:01

一、异常的概念

异常处理是一种处理错误的机制，它允许在程序运行中遇到问题时，不直接中断程序的正常流程，而是跳转到特定的处理代码中进行处理。C++ 使用 throw 语句抛出异常对象，并使用 try-catch 语句捕获和处理异常。

抛出异常：使用 throw 关键字抛出一个异常对象。抛出的对象通常是某个类型的实例（可以是内建类型，也可以是自定义类）。捕获异常：使用 try-catch 语句来捕获并处理异常。在 try 块中放置可能抛出异常的代码，catch 块则处理异常。

二、异常的抛出和捕获

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

//一个简单的捕获异常的程序
double Divide(int a, int b)
{
	// 当b == 0时抛出异常
	if (b == 0)
	{
		string s("Divide by zero condition!");
		throw s;
	}  
	else
	{
		return ((double)a / (double)b);
	}

	return 0;
} 
void Func()
{
	int len, time;
	cin >> len >> time;

	cout << Divide(len, time) << endl;
	
} 
int main()
{
	while (1)
	{
		try
		{
			Func();
		} 
		catch(const string & errmsg)
		{
			cout << errmsg << endl;
		}
	} 
	return 0;
}

被选中的处理代码是调用链中与该对象类型匹配且离抛出异常位置最近的那⼀个。根据抛出对象的类型和内容，程序的抛出异常部分告知异常处理部分到底发生了什么错误。（如果有多层捕获catch且捕获类型与该对象类型相同，选中的捕获就近。且注意类型匹配）

double Divide(int a, int b)
{
	try
	{
		// 当b == 0时抛出异常
		if (b == 0)
		{
			string s("Divide by zero condition!");
			throw s;
		} 
		else
		{
		return ((double)a / (double)b);
		}
	} 
	catch(int errid)
		{
			cout << errid << endl;
		} 
		return 0;
} 
void Func()
{
	int len, time;
	cin >> len >> time;
	try
	{
		cout << Divide(len, time) << endl;
	} 
	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;
}

当throw执行时，throw后面的语句将不再被执行。程序的执行从throw位置跳到与之匹配的catch模块，catch可能是同⼀函数中的⼀个局部的catch，也可能是调用链中另⼀个函数中的catch，控制权从throw位置转移到了catch位置。这里还有两个重要的含义：1、沿着调用链的函数可能提早退出。2、⼀旦程序开始执行异常处理程序，沿着调用链创建的对象都将销毁。（抛出的对象会在main中捕获，这个过程时随着这个调用链一层一层往下走。在走到中间这几层时虽然没有捕获，但是也会创建对象。但是当抛出的对象被捕获的时候沿着调用链所创建的对象也会销毁。）

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

try
{
	// 当b == 0时抛出异常
	if (b == 0)
	{
		string s("Divide by zero condition!");
		throw s;//比如这里抛出异常后，会生成一个异常对象的拷贝。当异常被catch捕获后，这个对象会销毁。
	} 
	else
	{
	return ((double)a / (double)b);
	}
} 
try
{
	// 当b == 0时抛出异常
	if (b == 0)
	{
		string s("Divide by zero condition!");
		throw s;//比如这里抛出异常后，会生成一个异常对象的拷贝。当异常被catch捕获后，这个对象会销毁。
	} 
	else
	{
	return ((double)a / (double)b);
	}
}

三、栈展开

抛出异常后，程序暂停当前函数的执行，开始寻找与之匹配的catch子句，首先检查throw本身是否在try块内部，如果在则查找匹配的catch语句，如果有匹配的，则跳到catch的地方进行处理。如果当前函数中没有try/catch子句，或者有try/catch⼦句但是类型不匹配，则退出当前函数，继续在外层调用函数链中查找，上述查找的catch过程被称为栈展开。如果到达main函数，依旧没有找到匹配的catch子句，程序会调用标准库的 terminate 函数中止程序如果找到匹配的catch子句处理后，catch子句代码会继续执行。

四、查找匹配的处理代码

⼀般情况下抛出对象和catch是类型完全匹配的，如果有多个类型匹配的，就选择离他位置更近的那个。
如果到main函数，异常仍旧没有被匹配就会终止程序，不是发生严重错误的情况下，我们是不期望程序终止的，所以⼀般main函数中最后都会使用catch(…)，它可以捕获任意类型的异常，但是不知道异常错误是什么。

int main()
{
	while (1)
	{
		try
		{
			Func();
		} 
		catch(const string & errmsg)
		{
			cout << errmsg << endl;
		}
		catch(...)
		{
			cout << "Unkown Exception" << endl;
		}
	} 
	return 0;
}

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

⼀般大型项目程序才会使用异常，下⾯我们模拟设计⼀个服务的几个模块，每个模块的继承都是Exception的派生类，每个模块可以添加自己的数据最后捕获时，我们捕获基类就可以

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 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 SqlException("权限不⾜", 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(1));
		try
		{
			HttpServer();
		} catch(const Exception & e) // 这⾥捕获基类，基类对象和派⽣类对象都可以被捕获
		{
		cout << e.what() << endl;
		} 
		catch (...)
		{
			cout << "Unkown Exception" << endl;
		}
	} return 0;
}

五、异常重新抛出

有时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)
	{
		// 发送消息失败，则再重试3次
		for (size_t i = 0; i < 4; i++)
		{
			try
			{
				_SeedMsg(s);
				break;
			} catch(const Exception & e)
			{
				// 捕获异常，if中是102号错误，⽹络不稳定，则重新发送
				// 捕获异常，else中不是102号错误，则将异常重新抛出
				if (e.getid() == 102)
				{
					// 重试三次以后否失败了，则说明⽹络太差了，重新抛出异常
					if (i == 3)
						throw;
					cout << "开始第" << i + 1 << "重试" << endl;
				} 
				else
				{
				throw;
				}
			}
		}
	} 
	int main()
	{
		srand(time(0));
		string str;
		while (cin >> str)
		{
			try
			{
				SendMsg(str);
			} catch(const Exception & e)
			{
				cout << e.what() << endl << endl;
			} 
			catch(...)
			{
				cout << "Unkown Exception" << endl;
			}
		} 
		return 0;
	}

六、异常安全问题

异常抛出后，后⾯的代码就不再执行，前面申请了资源(内存、锁等)，后⾯进行释放，但是中间可能会抛异常就会导致资源没有释放，这⾥由于异常就引发了资源泄漏，产⽣安全性的问题。中间我们需要捕获异常，释放资源后面再重新抛出，当然后⾯智能指针章节讲的RAII方式解决这种问题是更好的。其次析构函数中，如果抛出异常也要谨慎处理，比如析构函数要释放10个资源，释放到第5个时抛出异常，则也需要捕获处理，否则后面的5个资源就没释放，也资源泄漏了。《Effctive C++》第8 个条款也专门讲了这个问题，别让异常逃离析构函数。

七、noexcept

对于用户和编译器而言，预先知道某个程序会不会抛出异常大有裨益，知道某个函数是否会抛出异常有助于简化调用函数的代码。 C++98中函数参数列表的后面接throw()，表示函数不抛异常，函数参数列表的后⾯接throw(类型1,类型2…)表示可能会抛出多种类型的异常，可能会抛出的类型用逗号分割。 C++98的方式过于复杂，实践中并不好用C++11中进行了简化，函数参数列表后面加noexcept表示不会抛出异常，啥都不加表示可能会抛出异常。

编译器并不会在编译时检查noexcept，也就是说如果⼀个函数用noexcept修饰了，但是同时又包含了throw语句或者调用的函数可能会抛出异常，编译器还是会顺利编译通过的(有些编译器可能会报个警告)。但是⼀个声明了noexcept的函数抛出了异常，程序会调用 terminate 终止程序。 noexcept(expression)还可以作为⼀个运算符去检测⼀个表达式是否会抛出异常，可能会则返回 false，不会就返回true。

码农公寓