C++异常

在C++代码中，程序可能会出现错误。

程序会出现的错误有两种：

1.语法错误———编译错误

2.运行错误———运行异常，简称异常

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

1.终止程序，如assert.缺点：用户难以接受，如发生内存错误，除0错误时就会终止程序。

2.返回错误码。缺陷：需要程序员自己去查找对应的错误，如程序的很多库的接口函数都是通过错误码放到errno中，表示错误。

3.C标准库中setjmp和longjmp组合。（不是很常用）

一.C++异常概念

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

异常的特点

1.偶然性，程序运行中，异常并不总是会发生的。

2.可预见性，异常的存在和出现是可以预见的。

* throw：当问题出现时，程序会抛出一个异常。这是通过使用throw关键字来完成的。

*catch：再你想要处理问题的地方，通过异常处理程序捕获异常。catch关键字用于捕获异常，可以有多个catch进行捕获。

*try:try块中的代码标识将被激活的特定异常，它后面通常跟着一个或多个catch块。

如果有一个块抛出一个异常，捕获异常的方法会使用try和catch关键字，try块中存放可能抛出异常的代码，try块中的代码称为保护代码。（示范代码如下）

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

int chu(int n,int m)
{
	if (m == 0)
	{
		throw string("发生除0错误");
	}
	return n / m;
}

int main()
{  
	try
	{
		int n, m;
		cin >> n >> m;
		cout << chu(n, m) << endl;
	}
	catch (const string& err)
	{
		cout << err << endl;
	}
    catch(int err)
    {
        cout<<err<<endl;
    }
    catch(...)
    {
        cout<<"未知错误"<<endl;
    }
	return 0;
}

二.异常的用法

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

1.异常是通过抛出对象引发的，该对象的类型决定了应该激活哪个catch块的代码。

2.被选中的处理代码是调用链中与该对象类型匹配且抛出异常位置最近的那一个。

3.抛出异常后，会生成一个异常对象的拷贝，因为抛出的异常对象可能是一个临时对象，所以会生成一个拷贝对象，这个拷贝的临时对象会在被catch以后销毁（这里的处理类似函数的传值返回），所以抛出的可能是一个拷贝。

4.catch (...)可以捕获没有匹配的任意类型的异常，但问题是异常错误未知。（一般放在最后接收未知错误，因为抛出必须接收，避免没捕获异常，导致程序终止）

5.实际上抛出和捕获的匹配机制则有个例外，并不都是类型完全匹配，可以抛出的派生对象，使用基类捕获，这个在实际中很实用。（后面会介绍）

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

1.首先检查throw本身是否在try块内部，如果是再查找匹配的catch语句。如果有匹配的，则调用catch的地方进行处理。

2.没有匹配的catch则退出当前函数栈，继续在调用函数的栈中进行查找匹配的catch。

3.如果到达main函数的栈，依旧没有匹配的，则终止程序。上述这个沿着调用链查找匹配的catch子句的过程称为栈展开。所以实际中我们最后一个都要加上一个catch(...)捕获任意类型的异常，否则当有异常没捕获，程序就会终止。

4.找到匹配的catch子句处理以后，会继续沿着catch子句后面继续执行。

流程如图

3.异常安全

1.构造函数完成对象的构造和初始化，最好不要在构造函数中抛出异常，否则可能会导致对象不完整或没有完全初始化。

2.析构函数主要完成资源的清理，最好不要在析构函数内抛出异常，否则可能会导致资源泄露（内存泄漏、句柄未关闭等问题）。

3.C++中异常经常会导致资源泄露问题，比如在new和delete中抛出了异常，导致内存泄漏，在lock和unlock之间抛出异常导致死锁，C++经常使用RAII来解决上述问题。

注意！！！

在new/fopen/lock后，在delete/fclose/unlock前，如果抛出异常，通常要用异常的重新抛出，中途捕获，再抛出，是为了释放资源，防止资源的泄露。

4.异常规范

1.异常规格说明的目的是为了让函数使用者知道该函数可能抛出的异常有哪些。可以在函数的后面接throw（类型），列出这个函数可能抛出的所有异常类型。

2.函数的后面接throw()，表示不抛异常。

3.若无异常接口声明，则此函数可以抛出任意类型的异常。

 

四.自定义异常体系

在实际使用中，我们可以去继承Exception类实现自己的异常类，但实际上很多公司像上面一样自己定义一套异常继承体系。因为C++标准库设计的不够好。

下面是抛出的派生对象，使用基类捕获的代码实现（类似多态）

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

//基类
class Exception
{
public:
	Exception(const char* errmsg, int errid)
		:_errmsg(errmsg), _errid(errid)
	{}
	virtual string what() = 0;
protected:
	int _errid;
	string _errmsg;
	//stack<string>_st;
};
//派生类
class SqlException:public Exception
{
public:
	SqlException(const char* errmsg,int errid)
		:Exception(errmsg,errid)
	{}
	virtual string what()
	{
		return"数据库错误" + _errmsg;
	}
};
class NetworkException :public Exception
{
public:
	NetworkException(const char* errmsg,int errid)
		:Exception(errmsg,errid)
	{}
	virtual string what()
	{
		return "网络错误" + _errmsg;
	}
};
void ServerStart()
{
	if (rand() % 3 == 0)
		throw SqlException("数据库启动失败",1);
	if (rand() % 7 == 0)
		throw NetworkException("网络连接失败",3);
	cout << "正常运行" << endl;
}
int main()
{
	 for (size_t i = 0; i < 10; i++)
	{
		try
		{
			ServerStart();
		}
		catch (Exception& e)
		{
			cout << e.what() <<endl;
		}
		catch (...)
		{
			cout << "未知异常" << endl;
		}
	}
	return 0;
}

五.标准库异常体系

C++提供了一系列的异常，定义在<exception>中，我们可以在程序中使用哦那个这些的异常。它们是以父子类型结构组织起来的，如下所示

 下表是对以上的说明

六.异常的优缺点

优点:
1、将可能出现异常的代码和异常处理代码隔离开来，结构更清晰。清晰的包含错误信息。相比错误码的方式可以清晰准确的展示出错误的各种信息，甚至可以包含堆栈调用的信息，这样可以帮助更好的定位程序的bug。
2、面对T operator[](int i)这样函数越界错误，异常可以很好的解决。

3.把内层错误的处理直接转移到适当的外层来处理，化简了处理流程。

4、很多第三方库都是用异常，我们也使用异常，可以更好的使用他们。比如boost、gtest、gmock

缺点:
1、异常会导致执行流乱跳。会给我们调试分析程序bug带来一些困难。

2、C++没有GC，异常可能会导致资源泄露等异常安全问题。需要学会使用RAII来解决。

3、C++的库里面的异常体系定义不太好用，很多公司都会选择自己定义。

4、C++的异常语言可以抛任意类型的异常，如果项目中没有做很好规范管理，那么会非常的混乱，所以一般需要定义出继承体系的异常规范。

异常整体而言还是一个利大于弊的东西，所以实际日常练习或者小项目，不太使用。

公司一般还是会选择异常来处理错误。