C++11 异常

1. C语言处理错误的方法

在传统的C语言中，程序处理错误的方法基本有两种

1. 终止程序 比如：assert()断言 缺陷：用户体验不好，发生错误程序直接终止。
2. 返回错误码 缺陷：需要通过错误码手动查找对应的错误，比较麻烦。

2. 异常的引入

为了解决上述的缺陷，C++引入了异常

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

相关关键字

• throw： 通过该关键字抛出一个异常
• try：监控抛出异常的代码，后面一般更多个catch
• catch：捕获throw的异常

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

3. 异常的使用

3.1 异常的抛出和捕获

抛出和匹配原则：

1. 异常是通过抛出对象类型而引发的，catch捕获抛出的异常是根据抛出对象的类型决定的。
2. 在对象类型匹配的时候，距离近的catch优先捕获。
3. 抛出异常对象后，会生成一个异常对象的拷贝，因为抛出的异常对象可能是一个临时对象，所以会生成一个拷贝对象，这个拷贝的临时对象会在被catch以后销毁，类似于函数传值返回
4. catch(…)可以捕获任意类型的异常，问题是不知道异常错误是什么，一般用于保底。
5. 实际中抛出和捕获的匹配原则有个例外，并不都是类型完全匹配，可以抛出的派生类对象，使用基类捕获，这个在实际中结合多态机制非常实用。

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

1. 首先检查throw本身是否在try块内部，如果是再查找匹配的catch语句。如果有匹配的，则调到catch的地方进行处理.(就近原则)
2. 没有匹配的catch则退出当前函数栈，继续在调用函数的栈中进行查找匹配的catch
3. 如果到达main函数的栈，依旧没有匹配的，则终止程序，所以一般用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<<"unkown exception"<<endl;
	}
	return 0;
}

3.2 异常的重新抛出

对于一些情况，不能直接抛出异常，需要经过一些处理，所以先在本层捕获，处理完之后，然后再重新抛出异常给下一层处理，我们举个例子看看

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 (...)
	{

		delete[] array;
		throw;
	}
	// 如果没有catch，该段代码不会执行，所以造成了内存泄漏

	delete[] array;
}

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

3.3 异常安全

异常带来了很多好处，但同时也有坏处，原因来自throw异常之后，可以直接跳跃到对应的catch，有些代码执行不到，导致出现安全问题。

• 构造函数完成对象的构造和初始化，最好不要在构造函数中抛出异常，否则可能导致对象不完整或没有完全初始化
• 析构函数主要完成资源的清理，最好不要在析构函数内抛出异常，否则可能导致资源泄漏
• C++中异常经常会导致资源泄漏的问题，比如在new和delete中抛出了异常，导致内存泄漏，在lock和unlock之间抛出了异常导致死锁

为了解决上述问题，可以通过程序员编码解决，但是太繁琐了比如

void fun()
{
	int* p1 = new int[10];
	int* p2, *p3;
	try
	{
		p2 = new int[20];
		try {
			p3 = new int[30];
		}
		catch (...)
		{
			delete[] p1;
			delete[] p2;
			throw;
		}
	}
}

只有这样做才能保证异常安全，太繁琐了，所以后面C++11引入了智能指针来解决这个问题。

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;

这个用的很少了解一下就行。