[C++](25)异常

异常概念

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

1. 终止程序，如assert，缺点：方法太过暴力，用户难以接受，通常针对严重错误。
2. 返回错误码，缺点：需要程序员自己去查找对应的错误

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

• throw：当问题出现时，程序会抛出一个异常，这是通过关键字 throw 来完成的。
  • throw 后面可以跟任意类型的对象
• catch：在想要处理问题的地方，通过异常处理程序捕获异常
• try：try 块中的代码标识将被激活的特定异常，它后面通常跟着一个或多个 catch 块。
  • 抛出异常后不捕获，程序终止

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

try
{
	// 保护的标识代码
}
catch (ExceptionName e1)
{
	// catch 块
}
catch (ExceptionName e2)
{
	// catch 块
}
catch (ExceptionName eN)
{
	// catch 块
}

异常的使用

异常的抛出与捕获

1. 异常由 throw 抛出，抛出的对象的类型决定了应该执行哪个 catch 块，抛出派生类对象可以使用基类捕获。
2. 抛出异常对象后，会生成一个异常对象的拷贝，也就是临时对象，类似于函数的传值返回

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

1. 抛出异常后，首先检查 throw 本身是否在 try 块内部，如果是，再查找匹配的 catch 语句。如果有匹配的，则调到catch的地方进行处理
2. 不在当前函数 try 块内部或没有匹配的 catch 则退出当前函数栈，继续在上一个函数栈中查找匹配的 catch
3. 如果到达 main 函数的栈依旧没有匹配的，则终止程序。
   • 上述沿着调用链查找匹配的 catch 子句的过程称为栈展开。所以实际中，我们会在最后加一个catch(…)捕获任意类型的异常，否则当有异常没有捕获，程序就会直接终止。
4. 找到匹配的 catch 子句并处理以后，会继续沿着 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 << "未知异常" << endl;
	}
}
//输入：
//1 0
//输出：
//Division by zero condition!

---

捕获new失败的异常

int main()
{
	try
	{
		int* myarray = new int[10000];
	}
	catch (std::bad_alloc& ba)
	{
		std::cerr << "bad_alloc caught: " << ba.what() << '\n';
	}
	return 0;
}

捕获类型也可以写成 exception，它是 bad_alloc 的基类。

查看文档exception - C++ Reference (cplusplus.com)

可以看到库里面有自己的一套异常类型，它们都是 exception 的派生类，可以用 exception 捕获

如果一个项目中大家都随意抛异常，对外层的调用者很不友好。所以实际使用中很多公司都会制定自己的继承异常体系，规定一个基类，大家都抛这个基类的派生类对象，这样捕获时只要写基类就可以了。

异常重新抛出

下面这段程序有什么问题吗？

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;
	throw;

	// ...
	cout << "delete []" << array << endl;
	delete[] array;
}
int main()
{
	try
	{
		Func();
	}
	catch (const char* errmsg)
	{
		cout << errmsg << endl;
	}
	return 0;
}

可以看到，在 Func 的开头我们 new 了一个数组，然后调用了 Division 函数，如果此时发生除以0的错误，就会立刻被 main 函数里的 catch 捕获，然后结束。 new 的数组没有被释放，出现内存泄漏。

如何解决呢？

在 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()
{
	// 这里可以看到如果发生除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(类型) 可以明确指出这个函数抛什么类型的异常
• 函数后面加 throw() ，表示该函数不抛异常
• C++11 中新增关键字 noexcep ，加在函数后面表示明确不抛异常

以上都只是规范，不是必须

// 表示该函数会抛出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;

异常的优缺点

优点：

1. 能够清晰准确地说明错误信息

   相比错误码，异常可以直接展示信息，不用去查表。对于错误码来说，如果函数调用链较深，深层的函数的错误码需要层层返回，最外层才能拿到错误码，异常则不需要。

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

缺点：

1. 执行流乱跳，难以控制，增加调试和分析程序的困难度。有点类似被人嫌弃的 goto 语句。并且由于 C++ 没有垃圾回收机制，异常非常容易导致内存泄漏，死锁等异常安全问题。
2. 异常体系混乱，C++标准库的异常体系定义不够好，导致大家各自定义自己的异常体系。异常规范没有强制，一些人写的程序随意抛异常，对外层捕获十分不友好。

总体来说，异常还是利大于弊，面向对象语言还是鼓励使用异常的。