C++ 异常处理

注意：本文中代码均使用 Qt 开发编译环境

异常处理###

1.throw表达式语法：
throw 表达式

2.try语句块语法：
try
复合语句 // 代码保护段
catch(异常接口声明) // 异常的类型，与函数形参类似，可以是某个类型的值，也可以是引用
复合语句 // 异常处理程序
catch(异常接口声明)
复合语句
…

如果某段程序中发现了自己不能处理的异常，就可以使用throw表达式抛掷这个异常，将它抛掷给调用者。throw的操作数表示异常类型，语法上与return语句的操作数相似，如果程序中有多处需要抛掷的异常，应该用不同的操作数类型来相互区别，操作数的值不能用来区别不同的异常。

类型可以是任何有效的数据类型，包括C++的类。当异常被抛掷后，catch子句便依次被检查，若某个catch子句的异常类型声明与被抛掷的异常类型一致，则执行该段异常处理程序。如果异常类型声明是一个省略号（…），catch子句便处理任何类型的异常，这段处理程序必须是try块的最后一段处理程序。

例子：

#include <QCoreApplication>
#include <QDebug>

int Div(int x,int y);

int main(){

    try{
       qDebug() << "5/2 = " << Div(5, 2);
       qDebug() << "8/0 = " << Div(8, 0);
       qDebug() << "7/1 = " << Div(7, 1);
    } catch(int) {
       qDebug() << "except of deviding zero.";
    }

    qDebug() << "that's ok.";
    return 0;
}

int Div(int x, int y) {
    if(y==0) {
       throw y;
    }
    return x/y;
}

运行结果：

抛出异常

异常被抛掷后，程序流跳至try语句块之外继续执行，例子中的下列语句没有被执行：

qDebug() << "7/1 = " << Div(7, 1);

另外，catch处理程序出现的顺序很重要，因为在一个try块中，异常处理程序是按照他出现的次序被检查的。只要找到一个匹配的异常类型，后面的异常处理都将被忽略。

异常接口声明###

为了加强程序的可读性，使函数的用户能够方便的知道所使用的函数会抛出那些异常，可以在函数的声明中列出这个函数可能抛掷的所有异常类型，例如：
void fun() throw (A,B,C,D);
这表明函数fun()能够且只能够抛掷类型A、B、C、D及其子类型的异常。

void fun();可以抛掷任何类型异常。

一个不抛掷任何类型异常的函数可以进行如下形式的声明：
void fun() throw();

异常处理中的构造与析构###

C++异常处理的真正能力，不仅在于它能够处理各种不同类型的异常，还在于它具有为异常抛掷前构造的所有局部对象自动调用析构函数的能力。

在程序中，找到一个匹配的catch异常处理之后，如果catch字句的异常类型声明是一个值参数，则其初始化方式是复制被抛掷的异常对象。如果catch字句的异常类型声明是一个引用，则其初始化方式是使该引用指向异常对象。

当catch字句的异常类型声明参数被初始化后，栈的展开过程便开始了。这包括将从对应的try块开始到异常被抛掷处之间构造（且尚未构造）的所有自动对象进行析构。析构的顺序与构造的顺序相反。然后程序从最后一个catch处理之后开始恢复执行。

示例代码：

#include <QCoreApplication>
#include <QDebug>

void MyFunc(void);

class Expt
{
public:
   Expt(){}
   ~Expt(){}

   const char *ShowReason() const{
       return "Expt 类异常。";
   }
};


class Demo{
public:
   Demo();
   ~Demo();
};

Demo::Demo(){
   qDebug()<<"构造Demo。";
}

Demo::~Demo(){
   qDebug()<<"析构Demo。";
}

void MyFunc(){
   Demo D;
   qDebug()<<"在MyFunc()中抛掷Expt类异常。";
   throw Expt();
}

int main()
{

   qDebug()<<"在main()函数中。";

   try {
       qDebug()<<"在try块中，调用MyFunc()。";
       MyFunc();
   } catch (Expt E) {
       qDebug()<<"在catch异常处理程序中。";
       qDebug()<<"捕获到Expt类型异常：";
       qDebug()<<"E.ShowReason(): " << E.ShowReason();
   } catch (char * str) {
       qDebug()<<"捕获到其它的异常："<<str;
   }

   qDebug() << "回到main函数。从这里恢复执行。";

   return 0;
}

运行结果：

运行效果

注意在此例中，在两个catch处理器中都说明了异常参量:

catch (Expt E){//…
} catch (char * str){//…
}

其实也可以不说明这些参量（E和str）。在很多情况下只要通知处理程序有某个特定类型的异常已经产生就足够了。但是需要访问异常对象时就要说明参量，否则将无法访问catch处理程序子句中的那个对象。例如：

catch (Expt E) {
//在这里不能访问Expt异常对象
}

用一个不带操作数的throw表达式可以将当前正在被处理的异常再次抛掷，这样一个表达式只能出现在一个catch处理程序中或在catch处理程序内部调用的函数中。再次抛掷的异常对象是源异常对象（不是拷贝）。例如：
try {
throw CSomeOtherException();
} catch (…) //处理所有异常
{
//对异常做出响应（也许仅仅是部分的）
//…
throw; //将异常传递给某个其它处理器
}