深度剖析C++ 异常机制

传统排错

我们早在 C 程序里面传统的错误处理手段有：

终止程序，如 assert；缺陷是用户难以接受，说白了就是一种及其粗暴的手法，比如发生内存错误，除0错误时就会终止程序。
返回错误码。缺陷是需要我们自己去查找错误，如系统的很多库的接口函数都是通过把错误码放到 errno 中，表示错误。
C标准库中 setjmp 和 longjmp 组合（不常用）

实际中 C 语言基本都是使用返回错误码的方式处理错误，部分情况下使用终止程序处理非常严重紧急的错误，因此异常机制就时运而横空出世

概念

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

throw：当程序出现问题时，可以通过 throw 关键字抛出一个异常
try：try 块中放置的是可能抛出异常的代码，该代码块在执行时将进行异常错误检测，try 块后面通常跟着一个或多个 catch 块。
catch：如果try块中发生错误，则可以在 catch 块中定义对应要执行的代码块。

try-catch 语句的语法实例：

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

用法

异常是通过抛出对象而引发的，该对象的类型决定了应该激活哪个 catch 的处理代码，如果抛出的异常对象没有捕获，或是没有匹配类型的捕获，那么程序会终止报错

异常捕获和抛出

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

抛出异常对象后，会生成一个异常对象的拷贝，因为抛出的异常对象可能是一个临时对象，所以会生成一个拷贝对象 \color{red} {因为抛出的异常对象可能是一个临时对象，所以会生成一个拷贝对象}因为抛出的异常对象可能是一个临时对象，所以会生成一个拷贝对象，这个拷贝的临时对象会在被 catch 以后销毁（类似于函数的传值返回）

catch(…) 可以捕获任意类型的异常，但捕获后无法知道异常错误是什么，实际异常抛出和捕获的匹配原则有个例外，捕获和抛出的异常类型并不一定要完全匹配，可以抛出派生类对象，使用基类进行捕获，这个在实际中非常有用

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

当异常被抛出后，首先检查 throw 本身是否在 try 块内部，如果在则查找匹配的 catch 语句，如果有匹配的就跳到 catch 的地方进行处理

如果当前没有匹配的 catch 则退出当前函数栈，继续在上一个调用中进行查找 catch。找到匹配的 catch 子句并处理以后，会沿着 catch 子句后面继续执行，而不会跳回到原来抛异常的地方，如果到达 main 函数的栈，依旧没有找到匹配的 catch 则终止程序

比如下面的代码中调用了 func3，func3 中调用 func2，func2 中调用 func1，func1 中抛出了一个 string 的异常对象：

void func1()
{
	throw string("这是一个异常");
}
void func2()
{
	func1();
}
void func3()
{
	func2();
}
int main()
{
	try
	{
		func3();
	}
	catch (const string& s)
	{
		cout << "错误描述：" << s << endl;
	}
	catch (...)
	{
		cout << "未知异常" << endl;
	}
	return 0;
}

首先会检查 throw 本身是否在 try 块内部，这里就会因此退出 func1 所在的函数栈，继续在上一个调用栈中进行查找，即 func2 所在的函数栈，由于 func2 中也没有匹配的 catch，因此会继续复读套娃，最终在 main 函数栈中找到匹配的 catch

这时就会跳到 main 函数中对应的 catch 块中执行对应的代码块，执行完后继续执行该代码块后续的代码：

当然为了防止还有漏网之鱼，一般此时我们还会搞一个 catch(…) 进行全捕获。

异常的重新抛出

要知道一个 catch 是无法完全搞定异常的，如果我们对异常进行修正后，希望交付给上层调用链进行异常的异常信息日志记录，此时就需要我们重新对上层函数抛异常：

void func1()
{
	throw string("这是一个异常");
}
void func2()
{
	int* array = new int[10];
	func1();

	//省略函数对应实现
    //……
	delete[] array;
}
int main()
{
	try
	{
		func2();
	}
	catch (const string& s)
	{
		cout << s << endl;
	}
	catch (...)
	{
		cout << "未知异常" << endl;
	}
	return 0;
}

这里 func2 最后应该 delete 进行空间释放，但由于 func2 中途调用 func1 ，func1 内部抛出了一个异常，这时会直接跳转到 main 函数中的 catch 块执行对应的异常处理程序，并且在处理完后继续沿着 catch 块往后执行，这时就导致 func2 中内存块没有得到释放，造成了内存泄露！

此时我们应该在 func2 中先对 func1 抛出的异常进行捕获，捕获后先将内存释放再重新抛出异常，就可以避免内存泄露：

void func2()
{
	int* array = new int[10];
	try
	{
		func1();
		//省略函数对应实现
        //……
	}
	catch (...)
	{
		delete[] array;
		throw; //将捕获到的异常再次重新抛出
	}
	delete[] array;
}

try-catch 中 new 和 delete 之间可能还会抛出其他类型的异常，因此在 fun2 中最好再进行 catch(…) ，将申请到的内存 delete 后再通过throw 重新抛出；重新抛出异常对象时，此时 throw 可以不用指明要抛出的异常对象，其实 catch(…) 也不知道自己到底捕了个什么异常对象

安全第一条

还是那句话，道路千万条，抛异常要谨慎：

构造函数完成对象的构造和初始化，最好不要在构造函数中抛出异常，否则可能导致对象不完整或没有完全初始化
析构函数完成对象资源的清理，最好不要在析构函数中抛出异常，否则可能导致内存泄露，句柄未关闭等
C++ 中在 new 和 delete 中抛出异常经常是内存泄漏的罪魁祸首，在 lock 和 unlock 之间抛出异常导致死锁，C++ 经常使用 RAII 的方式来解决类似问题

规范使用

站在异常的严谨立场上， C++ 也在尽量提高咱的使用规范：

在函数的后面接throw(type1, type2, …)，列出这个函数可能抛掷的所有异常类型在函数的后面接throw()或noexcept（C++11），表示该函数不抛异常若无异常接口声明，则此函数可以抛掷任何类型的异常（异常接口声明不是强制的）

//这里可能会抛出A/B/C/D类型的异常
void func() 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();

异常体系

因为异常属实需要严谨与规范的操作，所以在很多公司里面都会制定自己的一套异常的规范管理：

公司中的项目一般会进行模块划分，让不同的人或小组完成不同的模块，如果不对抛异常这件事进行规范，那么在最外层捕获异常的冤种就会问候亲妈了，因为他会来给各位擦屁股，捕获大家抛出的所以异常对象 \color{red} {那么在最外层捕获异常的冤种就会问候亲妈了，因为他会来给各位擦屁股，捕获大家抛出的所以异常对象}那么在最外层捕获异常的冤种就会问候亲妈了，因为他会来给各位擦屁股，捕获大家抛出的所以异常对象

我们之前说过异常语法可以用基类捕获抛出的派生类对象，因此实际中都会先定义一个最基础的异常类，所有人抛出的异常对象都必须是继承于该异常类的派生类对象，，因此最外层就只需捕获基类就行了

最基础的异常类至少需要包含错误编号和错误描述两个成员变量，甚至还可以包含当前函数栈帧的调用链等信息，该异常类中一般还会提供两个成员函数，分别用来获取错误编号和错误描述

class Exception
{
public:
	Exception(int errid, const char* errmsg)
		:_errid(errid)
		, _errmsg(errmsg)
	{}
	int GetErrid() const
	{
		return _errid;
	}
	virtual string what() const
	{
		return _errmsg;
	}
protected:
	int _errid;  //错误编号
	string _errmsg; //错误描述
	//...
};

其他人如果要对这个异常类进行扩展，必须先继承基础异常类，然后按需添加某些成员变量，或是对虚函数what 进行重写，使其能告知更多的异常信息：

class CacheException : public Exception
{
public:
	CacheException(int errid, const char* errmsg)
		:Exception(errid, errmsg)
	{}
	virtual string what() const
	{
		string msg = "CacheException: ";
		msg += _errmsg;
		return msg;
	}
protected:
	//...
};
class SqlException : public Exception
{
public:
	SqlException(int errid, const char* errmsg, const char* sql)
		:Exception(errid, errmsg)
		, _sql(sql)
	{}
	virtual string what() const
	{
		string msg = "CacheException: ";
		msg += _errmsg;
		msg += "sql语句: ";
		msg += _sql;
		return msg;
	}
protected:
	string _sql; //异常的SQL语句
	//...
};

异常类的成员变量不能设置为私有，因为私有成员在子类中是不可见的。基类 Exception 中 what 成员函数最好定义为虚函数，方便子类对其进行重写，从而达到多态的效果