本文共 4042 字，大约阅读时间需要 13 分钟。

前言

在C语言中，我们使用的处理错误的几种方式：

• 终止错误：assert()，但出现某些错误就会导致程序直接终止，比如，内存问题
• 返回错误码。但需要我们自己去寻找错误原因
• C++标准库中的setjmp和longjmp。说实话，这个基本不用
  所以C++针对以上问题，提出了异常的解决方案。

概念

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

• throw：抛出异常
• try：try代码块中包含可能会出现异常的代码，并且要有 throw；try后面通常跟一个或多个 catch 块
• catch：捕获异常。

异常使用

异常抛出捕获匹配规则

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

异常栈展开原则

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

例如下面的代码：

#include 
   
    #include 
    
     using namespace std;double Div(int a, int b){
   	if (b == 0)		throw "nishizhuma";	else		return (double)a / (double)b;}void Func(){
   	int a, b;	cin >> a >> b;	cout << Div(a, b) << endl;}int main(){
   	try {
   		Func();	}	catch (const char* errmsg)	{
   		cout << errmsg << endl;	}	catch (...)	{
   		cout << "unknow exception" << endl;	}	system("pause");	return 0;}
    
   

1. 检查throw在try内部
2. Div函数中没有匹配的 catch，退出这个函数栈，继续找
3. Func中依然没有，退出这个函数栈，继续找
4. 主函数main中找到catch。看是否匹配：由于throw抛出的是一个字符串没第一个catch参数匹配，执行第一个catch代码段的内容

如果main函数改为这样，执行哪个catch？？

int main(){
   	try {
   		Func();	}	catch (const int errmsg)	{
   		cout << errmsg << endl;	}	catch (...)	{
   		cout << "unknow exception" << endl;	}	system("pause");	return 0;}

同理：先匹配第一个catch，发现throw抛出的是一个字符串，而第一个catch参数是一个整数，不执行，往下走。第二个catch接受任务参数的异常，匹配成功，执行代码。

异常的重新抛出

有些时候，单个的catch不能完全处理一个异常，在进行一些处理之后，希望交给外层的调用函数进行处理，catch则可以通过重新抛出异常交给上次函数进行处理。

double Div(int a, int b){
   	if (b == 0)		throw "nishizhuma";	else		return (double)a / (double)b;}void Func(){
   	int* array = new int[10];	try	{
   		int a, b;		cin >> a >> b;		cout << Div(a, b) << endl;	}	catch (...)	{
   		cout << "delete []" << array << endl;		delete[] array;		throw;	}	delete[] array;}int main(){
   	try {
   		Func();	}	catch (const char* errmsg)	{
   		cout << errmsg << endl;	}	catch (...)	{
   		cout << "unknow exception" << endl;	}	system("pause");	return 0;}

执行结果：

异常安全问题

• 构造函数完成对象的构造和初始化，最好不要在构造函数中抛出异常，否则可能导致对象不完整或没有初始化
• 析构函数完成资源的清理，最好不要在析构函数中抛出异常，有可能会到最后资源泄露
• 异常经常会导致资源泄露的问题，比如：new-delete，lock-unlock。但C++中一般使用RAII来解决该问题

注：如果new抛出异常，那么catch中一定要使用delete，因为捕获异常后，该函数中catch后面的代码不会被执行

基类、派生类异常问题

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

// 服务器开发中通常使用的异常继承体系class Exception{
   	protected:	string _errmsg;	int _id;	//list
   
     _traceStack;	// ...};class SqlException : public Exception{
   };class CacheException : public Exception{
   };class HttpServerException : public Exception{
   };int main(){
   	try{
   	// server.Start();	// 抛出对象都是派生类对象	}	catch (const Exception& e) // 这里捕获	父类对象就可以	{
   }	catch (...)	{
   	cout << "Unkown Exception" << endl;	}	return 0;}
   

也就是说：

捕获异常参数使用引用的原因

这里有一个问题：捕获异常为什么要使用引用？？

传值和引用对比

1. 传值会复制两次，传给catch时，抛出时都会复制。引用只复制一次，效率大大提高。
2. 值传递会带来切割问题。当传递派生类对象给参数是基类对象的catch时，会导致切割，即派生类的派生类成员被切割，只留基类的部分。

---

指针和引用对比

1. 抛出指针时，不需要复制对象，只需复制指针，效率增加，但是，不能抛出指向局部对象的指针，因为函数调用完毕，局部对象被销毁。
2. 抛出指向堆对象的指针时，new完之后没办法delete，因为没有办法知道传来的是全局对象或者static 对象或者是堆上的对象，所以，delete or not delete这就成一个问题了。

异常的优缺点

优点：

1. 异常对象定义好了，相比错误码的方式可以清晰准确的展示出错误的各种信息，甚至可以包含堆栈调用的信息，这样可以帮助更好的定位程序的bug。
2. 返回错误码的传统方式有个很大的问题就是，在函数调用链中，深层的函数返回了错误，那么我们需要层层返回错误，最外层才能拿到错误，就会很麻烦。
3. 很多的第三方库都包含异常，比如boost、gtest、gmock等等常用的库，那么我们使用它们也需要使用异常。
4. 很多测试框架都使用异常，这样能更好进行测试。
5. 部分函数使用异常更好处理比如T&operator这样的函数，如果pos越界了只能使用异常或者终止程序处理，没办法通过返回值表示错误。

缺点：

1. 异常会导致程序的执行流乱跳，并且非常的混乱，并且是运行时出错抛异常就会乱跳。这会导致我们跟踪调试时以及分析程序时，比较困难。
2. 异常会有一些性能的开销。这个影响基本忽略不计。
3. C++没有垃圾回收机制，资源需要自己管理。有了异常非常容易导致内存泄漏、死锁等异常安全问题。这个需要使用RAII来处理资源的管理问题。
4. C++标准库的异常体系定义得不好，导致大家各自定义各自的异常体系，非常的混乱。

总结：

• 异常尽量规范使用，否则后果不堪设想，随意抛异常，外层捕获的用户苦不堪言。所以异常规范有两点：一、抛出异常类型都继承自一个基类。二、函数是否抛异常、抛什么异常，都使用 func() throw();的方式规范化。
• 异常依然利大于弊，工程中还是建议使用

转载地址：http://xcwdb.baihongyu.com/