C++《异常》

前言：C++有一套独立的异常处理机制,今天就来做详细的介绍try,catch这两个词等

在C语言中处理错误的方式和缺陷有：

返回错误码。

缺陷：

1.错误码不好设置，比如：除0操作，就不好返回错误码。如果返回一个数字，可能会有两层含义，是错误，还是结果呢。一般我们会在参数加一个输出型参数返回结果，再规定成功和失败返回的数字。

2.需要程序员去查找错误码对应的含义。比如：很多系统接口函数都是把错误码放到全局变量errno中，表示错误。
终止程序。比如：发生越界，除0，内存错误等，会直接终止程序。

缺陷：并不能明确知道是什么错误。用户难以接收。

1、C++异常概念

异常是面向对象语言处理错误的一种方式。当一个函数出现自己无法处理的错误时，可以抛出异常，然后输的直接或者间接调用者处理这个错误。

有三个关键字：

throw：当问题出现，程序抛出一个异常。抛异常使用throw关键字完成。
catch：用于捕捉异常。catch(...)可以捕获任意类型的异常，主要时用来捕获没有显示捕获类型的异常。相当于条件判断中的else。
try：try中包含会出现异常的代码或者函数。后面通常会跟一个或者多个catch块。

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

注意：可以抛出任意类型的对象。抛出的异常必须捕获。try要和catch匹配使用，catch里的内容抛出异常时才执行，没有异常，不执行。

代码举例：

int test(){
	int a = 0;
	int b = 0;
	cin >> a >> b;
	if (b == 0){
		throw "除0错误";//抛出异常,异常的描述
	}
	return a / b;
}
 
int main(){
 
	try{
		cout << test() << endl;//会出现异常的代码
	}
	//捕获异常
	catch (const char* a){
		cout << a << endl;
	}
	catch (...){
		cout << "unknow exception" << endl;
	}
 
	system("pause");
	return 0;
}

运行结果：

1、异常的抛出和匹配原则

1. 异常是通过抛出对象而引发的，该对象的类型决定了应该激活哪个catch的处理代码。
2. 被选中的处理代码是调用链中与该对象类型匹配且离抛出异常位置最近的那一个。
3. 抛出异常对象后，会生成一个异常对象的拷贝，因为抛出的异常对象可能是一个临时对象，所以会生成一个拷贝对象，这个拷贝的临时对象会在被catch以后销毁。（这里的处理类似于函数的传值返回）
4. catch(...)可以捕获任意类型的异常，问题是不知道异常错误是什么。
5. 实际中抛出和捕获的匹配原则有个例外，并不都是类型完全匹配，可以抛出的派生类对象，使用基类捕获，这个在实际中非常实用，我们后面会详细讲解这个。

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

1. 首先检查throw本身是否在try块内部，如果是再查找匹配的catch语句。如果有匹配的，则调到catch的地方进行处理。
2. 没有匹配的catch则退出当前函数栈，继续在调用函数的栈中进行查找匹配的catch。
3. 如果到达main函数的栈，依旧没有匹配的，则终止程序。上述这个沿着调用链查找匹配的 catch子句的过程称为栈展开。所以实际中我们最后都要加一个catch(...)捕获任意类型的异常，否则当有异常没捕获，程序就会直接终止。
4. 找到匹配的catch子句并处理以后，会继续沿着catch子句后面继续执行。

如果在func2处匹配：

结论：按照函数调用链，一层一层往外找，直到找到匹配的catch块，直接跳到匹配的catch块执行，执行完catch，会继续往catch块后面的语句执行。相当于没有找到匹配的函数栈帧被释放了。

2、异常的重新抛出

有可能单个的catch不能完全处理一个异常，在进行一些矫正处理后，需要交给更外层的调用链函数来处理。catch可以做完矫正操作，再将异常重新抛出，交给更上层的函数进行处理。

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

3、异常安全问题

由于抛异常只要找到匹配的catch就直接跳到catch块执行，没有找到对应catch的函数就不会继续执行。这样导致函数的执行流回很乱。可能会导致一些问题。

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

有两种解决办法：

将异常捕获，释放资源后，将锁重新抛出。
使用RAII的思想解决。定义一个类封装，管理资源。当要使用时实例化一个类对象，将资源传入，当退出函数，调用对象析构函数，释放资源。

4、异常规范说明

异常规格说明，是使函数调用者直到函数可能会抛出哪些异常。可以在函数后面接throw(异常类型)，列出这个函数可能抛出的所有异常类型。
在函数后面加throw()或者noexcept表示不抛异常。
若没有接口声明表示，此函数可能会抛出任意类型的异常

// 这里表示这个函数会抛出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 new (std::size_t size, void* ptr) throw();
void* operator new (std::size_t size, void* ptr) noexcept;

5、自定义异常体系

实际使用中很多公司都会自定义自己的异常体系进行规范的异常管理，因为一个项目中如果大家随意抛异常，那么外层的调用者基本就没办法玩了，所以实际中都会定义一套继承的规范体系。这样大家抛出的都是继承的派生类对象，捕获一个基类就可以了

不同的部分可以抛出不同的异常,然后在总的main函数中使用基类捕获所有的异常再来进行特殊的处理

下面是一个简单的实现：

//基类
//异常
class Exception{
public:
	
	Exception(const char* str = nullptr, int id = 0)
		:_errmsg(str)
		, _id(id)
	{}
	virtual void what()const = 0;
protected:
	string _errmsg;//错误信息
	int _id;//错误码
};
//派生类
//数据库异常
class SqlException :public Exception{
public:
	SqlException(const char *str = nullptr, int id = 1)
		:Exception(str, id)
	{}
 
	virtual void what()const{
		cout << "error msg:" << _errmsg << endl;
		cout << "error id:" << _id << endl;
	}
};
//网络异常
class HttpException :public Exception{
public:
	HttpException(const char *str = nullptr, int id = 2)
		:Exception(str, id)
	{}
 
	virtual void what()const{
		cout << "error msg:" << _errmsg << endl;
		cout << "error id:" << _id << endl;
	}
};
//缓存异常
class CacheException :public Exception{
public:
	CacheException(const char *str = nullptr, int id = 3)
		:Exception(str, id)
	{}
 
	virtual void what()const{
		cout << "error msg:" << _errmsg << endl;
		cout<< "error id:" << _id << endl;
	}
};
 
void test(){
	//当网络连接失败，抛出这个异常即可
	//throw HttpException("Http fail", 2);
	//当缓存错误
	//throw CacheException("Cache error", 3);
	//当数据库错误
	throw SqlException("Sql error", 4);
}
 
int main(){
	try{
		test();
	}
    //用基类捕捉即可
	catch (const Exception& a){
		a.what();
	}
	catch (...){
		cout << "unknow exception" << endl;
	}
	system("pause");
	return 0;
}

6、C++标准库的异常体系

在C++库中也建立了一个异常体系。也给我们提供了一些异常类。我们可以在程序中使用这些标准异常，它们也是以父子类层次结构组织起来的。

说明：

int main()
{
 try{
 vector<int> v(10, 5);
 // 这里如果系统内存不够也会抛异常
 v.reserve(1000000000);
 // 这里越界会抛异常
 v.at(10) = 100; 
 }
 catch (const exception& e) // 这里捕获父类对象就可以
 {
 cout << e.what() << endl;
 }
 catch (...)
 {
 cout << "Unkown Exception" << endl;
 }
 return 0;
}