一、抛出 / 捕获 多个类型异常对象

---

1、标准异常类

在 C++ 语言中 , 提供了一系列的 " 标准异常类 " ,

这些 " 标准异常类 " 都继承了 std::exception 基类 ,

在 标准库 中 , 抛出的异常 , 都是 标准异常类 , 都是 std::exception 类的子类 ;

2、标准异常类继承结构

标准异常类 定义在 std 命名空间 , 标准异常类 基类 std::exception 定义在 <exception> 头文件中 ;

#include <exception>

标准异常类 基类 std::exception 中提供了 what() 函数 , 用于获取异常报错信息 , what 函数的原型如下 :

namespace std {

#pragma warning(push)
#pragma warning(disable: 4577) // 'noexcept' used with no exception handling mode specified
class exception
{
    _NODISCARD virtual char const* what() const
    {
        return _Data._What ? _Data._What : "Unknown exception";
    }
}

标准异常类的继承关系如下图所示 :

上图中 runtime_error 和 logic_error 两个重要的异常类型基类 ,

• logic_error 是 编译时 被预先检测出来的异常 , 编程足够规范可以避免此类异常 ; logic_error 定义在了 <stdexcept> 头文件中 , 继承 exception 异常基类 ;

class logic_error : public exception { // base of all logic-error exceptions

• runtime_error 是 运行时 不能被预先检测出的异常 ; runtime_error 定义在了 <stdexcept> 头文件中 , 继承 exception 异常基类 ;

// CLASS runtime_error
class runtime_error : public exception { // base of all runtime-error exceptions

使用标准异常类 , 使用前需要导入 <stdexcept> 头文件 ;

#include <stdexcept> 

3、常用的标准异常类

常用的标准异常类如下 : std::exception 是标准异常类 基类 , 定义了 what() 函数 , 该方法返回一个指向 C 字符串的指针 , 该字符串包含了描述异常的消息 ;

• std::bad_alloc : 当无法分配内存时 , 会抛出此异常 ;

• std::bad_cast : 当进行类型转换时 , 如果转换失败 , 会抛出此异常 ;

• std::bad_exception : 当异常处理程序无法处理异常时 , 会抛出此异常 ;

• std::logic_error : 当程序中出现逻辑错误时 , 会抛出此异常 ;

  • std::out_of_range : 当访问超出有效范围的数组元素、vector 或 string 时 , 会抛出此异常 ;
  • std::length_error : 当试图创建一个超过可表示长度的容器时 , 会抛出此异常 ;
  • std::domain_error : 当计算一个数学函数的结果时 , 如果结果不在定义域内 , 会抛出此异常 ;
  • std::invalid_argument : 当一个函数接收到无效的参数时 , 会抛出此异常 ;

• std::runtime_error : 当程序运行时发生错误时 , 会抛出此异常 ;

  • std::overflow_error : 当整数运算结果太大 , 无法表示时 , 会抛出此异常 ;
  • std::range_error : 当数学函数的结果是无限大或 NaN 时 , 会抛出此异常 ;
  • std::underflow_error : 当数值下溢 , 即数值太小而无法表示时 , 会抛出此异常 ;

• std::system_error : 当系统调用失败时 , 会抛出此异常 ;

• std::system_fault : 这是一个用于指示由操作系统引起的错误的异常类 ;

• std::bad_typeid : 当试图对一个对象使用 typeid 运算符 , 而该对象没有定义 typeid 时 , 会抛出此异常 ;

• std::bad_weak_ptr : 当使用无效的弱指针时 , 会抛出此异常 ;

• std::exception_ptr : 这是一个可以持有异常对象的指针类型 ;

• std::future_error : 当 future 对象的结果未能按预期准备就绪时 , 会抛出此异常 ;

• std::invalid_promise : 当 future 对象接收到无效的 promise 时 , 会抛出此异常 ;

• std::lock_error : 当尝试锁定一个已经被锁定的互斥量（mutex）时 , 或者当尝试解锁一个未被锁定的互斥量时 , 会抛出此异常 ;

• std::mutex_consistent_set : 当使用 std::set_lock_state 设置一个互斥量的状态时 , 如果该状态无效 , 会抛出此异常 ;

• std::deadlock : 当在两个或更多的线程间产生死锁时 , 会抛出此异常 ;

• std::unexpected : 当未捕获处理函数中抛出的异常时 , 会抛出此异常 ;

二、自定义异常类继承 std::exception 基类

---

1、自定义异常类继承 std::exception 基类

首先 , 导入 <stdexcept> 头文件 ;

#include <stdexcept> 

然后 , 自定义类继承 std::exception 类 , 通过构造函数设置异常信息 , 重写 what 函数 , 在该函数中返回异常信息 ;

// 自定义类实现标准异常类基类
class eSize : public exception {
public:
	// 构造函数设置异常信息
	eSize(const char* p)
	{
		this->m_p = p;
	}

	// 重写 what 函数
	virtual const char* what() {
		return m_p;
	}

	// 异常信息
	const char* m_p;
};

再后 , 抛出异常信息 , 都抛出 eSize 类型的自定义异常类信息 , 不再像之前一样 , 抛出多个类型的异常 ;

// 1. 在 函数 中 抛出异常
void fun(int a) {
	// 判定数字大小, 只有 60 时是合法的
	// 只要传入的参数不是 60 就需要抛出不同的异常
	if (a == 60) {
		// 合法
	}
	else if (a < 0) {
		throw eSize("参数为负数");
	}
	else if (a == 0) {
		throw eSize("参数为 0");
	}
	else if (a < 60) {
		throw eSize("参数太小");
	}
	else if (a > 60) {
		throw eSize("参数太大");
	}
}

最后 , 捕获并处理异常 , 只需要处理 eSize& 类型的异常即可 ;

	// 2. 捕获并处理异常
	try
	{
		// 调用可能产生异常的函数
		fun(0);
	}
	catch (eSize& e)
	{
		const char* what = e.what();
		cout << "捕获异常 : " << what << endl;
	}
	catch (...) {
		cout << "未知异常" << endl;
	}

2、完整代码示例 - 自定义异常类继承 std::exception 基类

代码示例 :

#include <iostream>
#include <stdexcept> 
using namespace std;

// 自定义类实现标准异常类基类
class eSize : public exception {
public:
	// 构造函数设置异常信息
	eSize(const char* p)
	{
		this->m_p = p;
	}

	// 重写 what 函数
	virtual const char* what() {
		return m_p;
	}

	// 异常信息
	const char* m_p;
};

// 1. 在 函数 中 抛出异常
void fun(int a) {
	// 判定数字大小, 只有 60 时是合法的
	// 只要传入的参数不是 60 就需要抛出不同的异常
	if (a == 60) {
		// 合法
	}
	else if (a < 0) {
		throw eSize("参数为负数");
	}
	else if (a == 0) {
		throw eSize("参数为 0");
	}
	else if (a < 60) {
		throw eSize("参数太小");
	}
	else if (a > 60) {
		throw eSize("参数太大");
	}
}

int main() {

	// 2. 捕获并处理异常
	try
	{
		// 调用可能产生异常的函数
		fun(0);
	}
	catch (eSize& e)
	{
		const char* what = e.what();
		cout << "捕获异常 : " << what << endl;
	}
	catch (...) {
		cout << "未知异常" << endl;
	}

	cout << "try-catch 代码块执行完毕" << endl;

	// 控制台暂停 , 按任意键继续向后执行
	system("pause");

	return 0;
};

执行结果 :

捕获异常 : 参数为 0
try-catch 代码块执行完毕
Press any key to continue . . .