C++ 异常

本文将通过三大部分来进行总结C++异常问题：

第一部分：C++异常的概念：

第二部分：异常的相关用法:

第三部分：异常的优缺点：

一.异常的概念：

我们知道在C语言中传统的处理错误的机制一般使用的有三种：
（1）终止程序，如assert判别；
（2）返回错误码；
（3）使用C标准库中的setjump和longjump组合；
但以上三种方式有一定的缺陷，当遇到些错误时立即终止程序，对于服务器开发来说就很难受；当将错误转换成错误码返回时需要程序员对应去查找，会消耗很多精力和时间；此外，C标准库中的组合我们一般用的很少。因此当使用传统的处理错误机制就会出现很多的问题，而C++中通过抛异常的方式来解决错误，让程序员可以很清晰的知道哪里出错，出错的原因是什么；

1.什么是异常：

异常是一种处理错误的方式，当一个函数发现自己无法处理的错误时就会抛出异常，让函数的直接或间接调用着来处理和解决这个错误；

2.关于异常的几个关键字及功能：

throw：主要功能是来完成程序抛出一个异常；

catch：用于捕获异常（可以有多个catch进行捕获）；

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

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

举个栗子：

#include <iostream>
using namespace std;
double Division (int a,int b){
   if(b==0){
      throw "Division by zero condition!"; 
   }
   return ((double) a / (double) b);
}
void Func(){
   int len,time;
   cin>>len>>time;
   cout<<Division(len,time)<<cout;
}
   
int main(){
   try{
      Fun();
   }
   catch(const char* err){
      cout<<err<<endl;
   }

   return 0;
}
         

执行结果：当b==0时，抛异常，此时会抛出错误等待调用者解决；

二.异常的使用：

1.异常的抛出和捕获：

（1）异常的抛出和匹配原则：

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

举例如下：

#include <iostream>
#include <stdlib.h>
using namespace std;
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;
	Division(len, time);
}

int main()
{
	try {
		Func();
	}
	catch (int err)
	{
		cout << __LINE__ << err << endl;
	}
	catch (const string& err)
	{
		cout << __LINE__ << err << endl;
	}
	catch (const char* err)
	{
		cout << __LINE__ << err << endl;
	}
	
	catch (...)
	{
		cout << "未知异常" << endl;
	}
	system("pause");
	return 0;
}

程序输出结果为：

由上面的程序可知：抛异常时被选中的处理代码是调用链中与该对象类型匹配且离抛出异常位置最近的那一个，该程序的输出结果为143行，即与该对象匹配；

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

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

2.异常的重新抛出：

有时候单个的catch不能完全处理一个异常，在进行一些校正处理以后，希望再交给更外层的调用链函数来处理，catch则可以通过重新抛出将异常传递给更上层的函数进行处理；

举个栗子：

#include <iostream>
#include <stdlib.h>
using namespace std;
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;    
    }
    
    system("pause");
    return 0; 
}

3.异常安全问题：

（1）构造函数完成对象的构造和初始化，最好不要在构造函数中抛出异常，否则可能导致对象不完整或没有完全初始化；
（2）析构函数主要完成资源的清理，最好不要在析构函数内抛出异常，否则可能导致资源泄漏(内存泄漏，句柄未关闭等) ；

三.异常的优缺点：

C++异常的优点：

1.相比错误码的方式可以清晰准确的展示出错误的各种信息，甚至可以包含堆栈调用的信息，这样可以帮助更好的定位程序的bug；
2.返回错误码的传统方式在函数调用链中，当深层的函数返回错误，我么需要一层一层返回错误，才能最终找到错误；
3.很多的第三方库都包含异常；
4.很多测试框架都使用异常，这样能更好的使用单元测试等进行白盒的测试；
5. 部分函数使用异常更好处理，比如构造函数没有返回值，不方便使用错误码方式处理；

C++异常的缺点：

1.异常会导致程序的执行流乱跳，并且非常的混乱，这就导致在跟踪调试程序时比较困难；
2. C++没有垃圾回收机制，资源需要自己管理。有了异常非常容易导致内存泄漏、死锁等异常安全问题，这时就需要使用RAII来处理资源的管理问题；
3.异常必须要规范使用，否则外层捕获的用户会非常麻烦；
异常规范有两点：（1）抛出异常类型都继承自一个基类；（2）函数是否抛异常、抛什么异常，都使用 func（） throw();的方式规范化处理；