C++处理异常--基础一

C++处理异常的机制引入 
    在一个小的程序中，可以用比较简单的方法处理异常，例如用if语句判别除数是否为0，如果是。则输出一个出错信息。但是在一个大的系统中，包含许多模块，每个模块义包含许多函数，函数之间又五相调用，比较复杂。如果在每一个函数中都设置处理异常的程序段，会使程序过于复杂和庞大。因此，C++采取的办法是：如果在执行一个函数过程中出现异常，可以不在本函数中立即处理，而是发出一个信息，传给它的上一级(即调用它的函数)，它的上级捕捉到这个信启后进行处理。如果上一级的函数也不能处理，就再传给其上一级，由其上一级处理。如此逐级上送，如果到最高一级还无法处理，最后只好异常终止程序的执行。
    这样做使异常的发现与处理不由同一函数来完成。好处是使底层的函数专门用于解决实际任务，而不必再承担处理异常的任务，以减轻底层函数的负担，而把处理异常的任务上移到某一层去处理。例如在主函数中调用十几个函数，只需在主函数中设置处理异常即可，而不必在每个函数中都设置处理异常，这样可以提高效率。

C++处理异常的机制组成: 
    C++处理异常的机制是由3个部分组成的，即检查(try)、抛出(throw)和捕捉(catch)。把需要检查的语句放在try块中，throw用来当出现异常时发出(形象地称为抛出，throw的意思是抛出)一个异常信息，而catch则用来捕捉异常信息，如果捕捉到厂异常信息，就处理它：

例1 给出三角形的三边a，b，c，求三角形的面积。只有a+b>c，b+c>a，c+a>b时才能构成三角形。设置异常处理，对不符合三角形条件的输出警告信息，不予计算。

#include <iostream>
#include <cmath>
using namespace std;
int main()
{ double triangle(double,double,double);
    double a,b,c;
    cin>>a>>b>>c;
    while(a>0 && b>0 && c>0)
        { cout<<triangle(a,b,c)<<endl;
           cin>>a>>b>>c; }
    return 0; }

double triangle(double a,double b,double c)
{ double area;
    double s=(a+b+c)/2;
    area=sqrt(s*(s-a)*(s-b)*(s-c));
    return area; }

运行情况如下 ：
    6 5 4／ (输入a，b，c的值) 
    9.92157 (输出三角形的面积) 
    1 1.5 2／ (输入a，b，c的值) 
    0.726184 (输{¨三角形的面积} 
    1 2 1 ／ (输人a，b，c的值) 
    o (输出三角形的面积，此结果显然不对，因为不是三角形) 
    1 0 6／ ( 输入a，b，c的值) (结束)

    程序没有对三角形条件(任意两边之和应大于第三边)进行检查，因此，当输入a=l，b=2，c=1时，则计算出三角形的面积为0，显然是不合适的。
    现在修改程序，在函数triangle中对三角形条件进行检查，如果不符合三角形条件，就抛出一个异常信息，在主函数中的try-catch块中调用triangle函数，检测有无异常信息，并相应处理。修改后的程序如下：

#include <iostream>
#include <cmath>
using namespace std;
int main()
{ double triangle(double,double,double);
    double a,b,c;
    cin>>a>>b>>c;
    try //在try块中包含要检查的函数 
    { while(a>0 && b>0 && c>0)
        { cout<<triangle(a,b,c)<<endl;
            cin>>a>>b>>c;}
   }
catch(double) //用catch捕捉异常信息并作相应处理 
{ cout<<"a="<<a<<",b="<<b<<",c="<<c<<",that is not a traingle!"<<endl;}
    cout<<"end"<<endl;
    return 0; }

double triangle(double a,double b,double c) //计算三角形的面积的函数 
{ double sqrt;
    double s=(a+b+c)/2;
    if (a+b<=c||b+c<=a||c+a<=b) throw a; //当不符合三角形条什抛出异常信息 
    return sqrt(s*(s-a)*(s-b)*(s-c)); }

程序运行结果如下： 
   6 5 4 (输入a，b，c的值) 
   9.92157 (计算出三角形的面积) 
   1 1.5 2 (输入a，b，c的值) 
   0.726184 (计算出三角形的面积) 
   1 2 1 (输入a,b，c的值) 
   a=1，b=2，c=1，that is not a triangle! (异常处理) 
   end

现在结合程序分析怎样进行异常处理。
    (1)首先把可能出现异常的、需要检查的语句或程序段放在try后面的花括号中。由于riangle函数是可能出现异常的部分，所以把while循环连同triangle函数放在try块中。这些语句是正常流程的一部分，虽然被放在by块中，并不影响它们按照原来的顺序执行。
    (2)程序开始运行后，按正常的顺序执行到try块，开始执行by块中花括号内的语句。如果在执行try块内的语句过程中没有发生异常，则catch子句不起作用，流程转到catch子句后面的语句继续执行。
    (3)如果在执行try块内的语句(包括其所调用的函数)过程中发生异常，则throw运算符抛出一个异常信息。请看程序中的triangle函数部分，当不满足三角形条件时，throw抛出double类型的异常信息a。throw抛出异常信息后，流程立即离开本函数，转到其上一级的函数(main函数)。因此不会执行triangle函数中if语句之后的return语句。
throw抛出什么样的数据由程序设计者自定，可以是任何类型的数据(包括自定义类型的据，如类对象)。
    (4)这个异常信息提供给try-catch结构，系统会寻找与之匹配的catch子句。现在a是double型，而catch子句的括号内指定的类型也是double型，二者匹配，即catch捕获了该异常信息，这时就执行catch子句中的语句，本程序输出a=1.b=2,c=1,that is not a triangle! 
    (5)在进行异常处理后，程序并不会自动终止，继续执行catch子句后面的语句。本程序输出“end”。注意并不是从出现异常点继续执行while循环。如果在try块的花括号内有10个语句，在执行第3个语句时出现异常，则在处理完该异常后，其余7个语句不再执行，而转到catch子句后面的语句去继续执行。
由于catch子句是用来处理异常信息的，往往被称为catch异常处理块或catch异常处理器。

异常处理的语法:

throw语句一般是由throw运算符和一个数据组成的，其形式为:

   throw 表达式；

try-catch的结构为:

   try
      { 被检查的语句}
   catch(异常信息类型[变量名])
      { 进行异常处理的语句}

说明： 
    (1)被检测的函数必须放在try块中，否则不起作用。
    (2)try块和catch块作为—个整体出现，catch块是try-catch结构中的一部分，必须紧跟在try块之后，不能单独使用，在二者之间也不能插入其他语句，
    (3)try和catch块中必须有用花括号括起来的复合语句，即使花括号内只有一个语句，也不能省略花括号。
    (4)一个try-catch结构中只能有一个try块，但却可以有多个catch块，以便与不同的异常信息匹配。
    (5)catch后面的圆括号中，一般只写异常信息的类型名，如
catch(double)
    catch只检查所捕获异常信息的类型: 异常信息可以是C++系统预定义的标准类型，也可以是用户自定义的类型(如结构体或类)。如果由throw抛出的信息属于该类型或其子类型，则catch与throw二者匹配，catch捕获该异常信息。
    catch还可以有另外一种写法，即除了指定类型名外，还指定变量名，如:
        catch(double d)
    此时如果throw抛出的异常信息是double型的变量a，则catch在捕获异常信息a的同时，还使d获得a的值，或者说d得到a的一个拷贝。什么时候需要这样做呢?有时希望在捕获异常信息时，还能利用throw抛出的值，如
    (6)如果在catch子句中没有指定异常信息的类型，而用了删节号“…”，则表示它可以捕捉任何类型的异常信息， 如: catch(…){cout<<"OK"<<endl；} 它能捕捉所有类型的异常信息，并输出”OK”。
    (7)try-catch结构可以与throw出现在同一个函数中，也可以不在同一函数中。当throw抛出异常信息后，首先在本函数中寻找与之匹配的catch，如果在本函数中无try-catch结构或找不到与之匹配的catch，就转到其上一层去处理，如果其上一层也无try-catch结构或找不到与之匹配的catch，则再转到更上一层的try-catch结构去处理，也就是说转到离开出现异常最近的try-catch结构去处理。
    (8)在某些情况下，在throw语句中可以不包括表达式，
    (9)如果throw抛出的异常信息找不到与之匹配的catch块，那么系统就会调用一个系统函数terminate，使程序终止运行。

例2 在函数嵌套的情况下检测异常处理。 
这是一个简单的例子，用来说明在try块中有函数嵌套调用的情况下抛出异常和捕捉异常的情况。

#include <iostream>
using namespace std;
int main()
{ void f1();
    try 
{ f1( ); } //调用fl() 
    catch (double)
       { cout<<"OK0!"<<endl;}
    cout<<"end0"<<endl;
    return 0; }

void f1()
   { void f2();
try 
   { f2(); } //调用f2() 
catch ( char )
   { cout<<"OK1!";}
cout<<"end1"<<endl; }

void f2()
   { void f3();
try 
   { f3();} //调用f3()
catch (int)
   { cout<<"Ok2!"<<endl;}
    cout<<"end2"<<endl; }

void f3()
   { double a=0; 
try 
{ throw a ;} //抛出double类型异常信息 
catch (float)
   { cout<<"OK3!"<<endl;}
    cout<<"end3"<<endl; }

分3种情况分析运行情况：
    (1)执行上面的程序。图1为有函数嵌套时异常处理示意图。

    (2)如果将f3函数中的catch子句改为catch(double)，而程序中其他部分不变，则f3函数中的throw抛出的异常信息立即被门函数中的catch子句捕获(因为抛出的是double型异常，catch要捕捉的也是double型异常，二者匹配)。于是执行catch子句中的复合语句，输出"OK3"，再执行catch子句后面的语句，输出"end3"。f3函数执行结束后，流程返回f2函数中调用f3函数处继续往下执行。
程序运行结果如下：
    OK31 (在f3函数中捕获异常)
    end3 (执行f3函数中最后一个语句时的输出)
    end2 (执行f2函数中最后一个语句时的输出)
    endl (执行u函数中最后一个浯句时的输出)
    endO (执行主函数中最后—个语句时的输出)
    (3)如果在此基础上再将f3函数中的catch块改为
        catch(double)
            { cout<<"OK3!"<<endl；throw；}
    f3函数中的catch子句捕获throw抛出的异常信息a，输出"OK3!"表示收到此异常信息，但它立即用"throw;”将a再抛出。由于a是double型，与f2和门函数中的catch都不匹配，因此最后被main函数中的catch子句捕获。程序运行结果如下：
OK3！ (在f3函数中捕获异常)
OKO! (在主函数中捕获异常)
endO (执行主函数中最后一个语句时的输出)

三、 在函数声明中进行异常情况指定

   

为了便于阅渎程序，使用户在看程序时能够知道所用的函数是否会抛出异常信息以及异常信息可能的类型，C++允许在声明函数时列出可能抛出的异常类型，如可以将例1中第二个程序的第3行改写为:

   double triangle(double，double，double)throw(double)；

表示triangle函数只能抛出double类型的异常信息。如果写成

    double triangle(double，double，double)throw(int，double，float，char)；

则表示triangle函数可以抛出int，double，float或char类型的异常信息。异常指定是函数声明的一部分，必须同时出现在函数声明和函数定义的首行中，否则在进行函数的另一次声明时，编泽系统会报告“类型不匹配”。
    如果在声明函数时未列出可能抛出的异常类型，则该函数可以抛出任何类型的异常信息。如例1中第2个程序中所表示的那样。

如果想声明一个不能抛出异常的函数，可以写成以下形式：

double triangle(double，double，double) throw()； //throw无参数

    这时即使在函数执行过程中出现了throw语句，实际上也并不执行throw语句，并不抛出任何异常信息，程序将非正常终止。

黄色部分在vc6.0测试了一下一样会抛出异常,我个人不赞同这个观点   

  四、 在异常处理中处理析构函数

    如果在try块(或try块中调用的函数)中定义了类对象，在建立该对象时要调用构造函数。在执行try块(包括在try块中调用其他函数)的过程中如果发生了异常，此时流程立即离开try块(如果是在try块调用的函数中发生异常，则流程首先离开该函数，回到调用它的try块处，然后流程再从try块中跳出转到catch处理块)。这样流程就有可能离开该对象的作用域而转到其他函数，因而应当事先做好结束对象前的请理工作，C++的异常处理机制会在throw抛出异常信息被catch捕获时，对有关的局部对象进行析构(调用类对象的析构函数)，析构对象的顺序与构造的顺序相反，然后执行与异常信息匹配的catch块中的语句。

例 在异常处理中处理析构函数。 
    这是一个为说明在异常处理中调用析构函数的示例，为了请晰地表示流程，程序中加入了一些cout语句，输出有关的信息，以便读者对照结果分析程序。

#include <iostream>
#include <string>
using namespace std;
class Student
    { public:
      Student(int n,string nam) //定义构造函数 
        { cout<<"construtor-"<<n<<endl;
           num=n;name=nam;}
        ~Student(){cout<<"destructor-"<<num<<endl;} //定义析构函数 
void get_data(); //成员函数声明 
       private:
        int num;
       string name; } ;

void Student::get_data()       //定义成员函数 
   { if(num==0) throw num;      //如num=O，抛出int型变量num 
    else cout<<num<<" "<<name<<endl; //若num不等O，输出num，name 
    cout<<"in get_data()"<<endl; //输出信息，表示目前在fet_data函数中 
    }

void fun()                  //过程函数 （注意可见性)
   { Student stud1(1101,"tan"); //建立对象studl 
     stud1.get_data();        //调用studl的getdata函数 
    Student stud2(0,"Li");     //建立对象stud2 
     stud2.get_data(); }      //调用smd2的get data函数 

int main()
{ cout<<"main begin"<<endl; //表示主函数开始了 
    cout<<"call fun()"<<endl; //表示调用fun函数 
    try
      {fun();} //调用fun函数 
   catch(int n)
    { cout<<"num="<<n<<",error!"<<endl;} //表示num=0出错 
       cout<<"main end"<<endl; //表示主函数结束 
        return 0; }

分析程序执行过程,程序运行结果如下：

main begiin
call fun()
constructor-110l     //对立Student类对象stud1,num=1101 
110l tan             //对象stud1调用Student类的成员函数get_data , num不等O 
in get_data()        //执行get_data 
constructor-0       //建立Student类对象stud2,num=0,抛出num. 
destructor-O        //调用Student类对象stud1的析构函数 
destructor-1101     //调用Student类对象stud2的析构函数 
num=O，error!     //表示num=0出错 。
main end         //表示主函数结束

本节简单地介绍了异常处理的机制和使用方法，读者将会在今后的实际应用中进一步掌握它们。