c++学习笔记(18.异常处理)

本节知识点：

1.异常与c语言的异常处理：

    a.异常就是代码中的一些特殊情况，如除法运算中除数为零的情况，还有就是一些函数中出现不符合要求的函数参数的情况，都属于异常情况！

    b.在c语言中对异常的处理通常有三种方式：

       第一种，最常用的就是条件判断

       第二种，goto语句

       第三种，longjmp()函数和setjmp()函数

条件判断的示例代码：

#include <cstdlib>#include <iostream>using namespace std;int MemSet(void* dest, unsigned int length, unsigned char v){    if( dest == NULL )    {        return -1;    }        if( length < 4 )    {        return -2;    }        if( (v < 0) || (v > 9) )    {        return -3;    }        unsigned char* p = (unsigned char*)dest;        for(int i=0; i<length; i++)    {        p[i] = v;    }        return 0;}int main(int argc, char *argv[]){    int ai[5];    double ad[4];    char ac[3];    int ret;        ret = MemSet(ai, sizeof(ai), 0);        if( ret == 0 )    {    }    else if( ret == -1 )    {    }    else if( ret == -2 )    {    }    else if( ret == -3 )    {    }        ret = MemSet(ad, sizeof(ad), 1);        if( ret == 0 )    {    }    else if( ret == -1 )    {    }    else if( ret == -2 )    {    }    else if( ret == -3 )    {    }        ret = MemSet(ac, sizeof(ac), 2);        if( ret == 0 )    {    }    else if( ret == -1 )    {    }    else if( ret == -2 )    {    }    else if( ret == -3 )    {    }        cout << "Press the enter key to continue ...";    cin.get();    return EXIT_SUCCESS;}

    c.可见条件判断的方法，使得正常逻辑的代码和异常处理的代码混合在一起，导致代码迅速膨胀，难以维护！而goto语句和setjmp()、longjmp()函数则可以将异常处理代码放在统一的地方，与正常逻辑代码分开。

2.c++中的异常处理：

   a.c++中有着自己的一套异常处理方式，没有使用goto语句和setjmp()、longjmp()函数，是因为它们的安全性实在是很低！

   b.c++中异常处理的语法

      try语句块处理正常逻辑

      catch语句块处理异常逻辑

      throw语句引发一个异常

示例代码：

#include <iostream>#define div_zero_error 1using namespace std;double div(double a, double b){if((-0.0000001<b)&&(b<0.0000001)){throw div_zero_error;}return a/b;}int main(){char a = 'c'; //try语句块外面依然可以放其他语句 try{ cout << div(2,3) << endl;throw a; //throw后面可以直接 放数据 也可以放变量 //throw 'd';cout << div(1,0) << endl;cout << div(5,2) << endl;}catch(int a){cout << "div_zero_error" << endl;}catch(char) //catch语句后面，可以只有变量类型，没有具体变量 {cout << "test_error" << endl;}return 0;}

注意：第一，并不是所有语句都要全部放在try或者catch语句块里面，可以放在try或者catch语句外面！

           第二，throw语句后面，可以直接放数据，也可以放变量

           第三，一个try语句后面可以有多个catch语句块，catch语句后面，可以只有变量类型，没有具体变量！
   c.当throw语句抛出一个异常的时候，首先在当前函数中看，throw语句是否在一个try语句块中，如果是则去判断这个try语句块对应的catch语句块中是否能够处理这个异常类型，如果不能处理或者throw语句不在一个try语句块中，则退出当前函数，返回到调用函数的位置看，看调用函数的语句是否在一个try语句块中，对应的catch是否能处理这个异常，不断重复返回到上层函数，直到遇到可以处理这个异常的catch语句。或者返回到了所有函数后，都无法处理抛出的这个异常，则程序异常终止！！！切记，即使异常在对应的catch语句块中完成了异常处理，程序也不能回到异常发生处或上层函数调用处继续执行了，程序只能接着处理异常的catch语句块后面继续执行！！！

如图：

   d.c++的这种异常处理方式与常规的条件判断比较，优势在于异常代码块与正常代码块是分开的，便于代码管理，同时也避免了大量的条件判断(因为每种异常都会有一个自己的返回值，当函数结束时，需要判断是那一种异常，所以就存在大量判断，而且是每次调用函数都要重新判断，不能代码复用，导致垃圾代码大量膨胀)，条件判断中多种异常的情况(即返回好几个值的情况)，可以使用多个catch语句块完成，catch类型多的时候尽量不要使用基本类型，使用自己创建的类类型！

      c++的这种异常处理与goto语句(setjmp函数)的比较，try.....catch语句，比goto语句要安全的多，如果是用goto语句进行跳转，这个过程根本就不考虑函数的建栈和退栈过程，它仅仅就是跳转过去执行而已！而throw语句，则不是！throw抛出异常的时候，是会退栈然后返回上层函数的，这一点要比goto安全多了！起码函数是正常结束的！而且，throw是一层一层的去寻找catch语句，在逻辑性上，也要比goto语句清晰很多！

try.....catch语句的示例代码：

#include <cstdlib>#include <iostream>using namespace std;void MemSet(void* dest, unsigned int length, unsigned char v){    if( dest == NULL )    {        throw -1;    }        if( length < 4 )    {        throw -2;    }        if( (v < 0) || (v > 9) )    {        throw -3;    }        unsigned char* p = (unsigned char*)dest;        for(int i=0; i<length; i++)    {        p[i] = v;    }}int main(int argc, char *argv[]){    int ai[5];    double ad[4];    char ac[3];        try    {        MemSet(ai, sizeof(ai), 0);        MemSet(ad, sizeof(ad), 1);        MemSet(ac, sizeof(ac), 2);    }    catch(int e)    {        cout<<e<<endl;    }        cout << "Press the enter key to continue ...";    cin.get();    return EXIT_SUCCESS;}

注意：上面代码是c++异常处理的常规用法！

比对代码：

#include <cstdlib>#include <iostream>using namespace std;int MemSet(void* dest, unsigned int length, unsigned char v){int ret = 0;    if( dest == NULL )    {        return  -1;    }        if( length < 4 )    {        return  -2;    }        if( (v < 0) || (v > 9) )    {        return  -3;    }        unsigned char* p = (unsigned char*)dest;        for(int i=0; i<length; i++)    {        p[i] = v;    }    return 0;}int main(int argc, char *argv[]){    int ai[5];    double ad[4];    char ac[3];        if(0==MemSet(ai, sizeof(ai), 0))    {}    else    {if(-1==MemSet(ai, sizeof(ai), 0)){cout << -1 << endl;}else if(-2==MemSet(ai, sizeof(ai), 0)){cout << -2 << endl;}else if(-3==MemSet(ai, sizeof(ai), 0)){cout << -3 << endl;}}if(0==MemSet(ad, sizeof(ad), 1)){}    else    {if(-1==MemSet(ad, sizeof(ad), 1)){cout << -1 << endl;}else if(-2==MemSet(ad, sizeof(ad), 1)){cout << -2 << endl;}else if(-3==MemSet(ad, sizeof(ad), 1)){cout << -3 << endl;}}if(0==MemSet(ac, sizeof(ac), 2)){}    else    {if(-1==MemSet(ac, sizeof(ac), 2)){cout << -1 << endl;}else if(-2==MemSet(ac, sizeof(ac), 2)){cout << -2 << endl;}else if(-3==MemSet(ac, sizeof(ac), 2)){cout << -3 << endl;}}    cout << "Press the enter key to continue ...";    cin.get();    return EXIT_SUCCESS;}

注意：上面就是使用条件判断的异常处理方式，可见代码膨胀的样子！但是使用条件判断可以保证每一个正常逻辑的代码都得到执行，而try.....catch语句就保证不了！因为当发生throw异常的时候，代码就会跳转到catch语句块中，然后从catch语句块往后执行了！会丢失throw语句后面部分的正常逻辑代码！
    e.同一个try语句块可以跟上多个catch语句块，同一个try语句块可以抛出多种不同类型的异常，不同类型的异常由不同的catch语句块负责处理！异常被抛出后会自上而下逐一匹配catch语句块，异常匹配时，不会进行默认类型转换！

示例代码：

#include <cstdlib>#include <iostream>using namespace std;int test(int i){    if( i == 1 )    {        throw -1;    }        if( i == 2 )    {        throw "ERROR";    }        if( i == 3 )    {        throw 0.5;    }        if( i == 4 )    {        throw 'd';    }        return i;}int main(int argc, char *argv[]){    for(int i=0; i<4; i++)    {        try        {            cout<<test(i)<<endl;        }        catch(int e)        {            cout<<"Int: "<<e<<endl;        }        catch(const char* e)        {            cout<<"const char*: "<<e<<endl;        }        catch(double e)        {            cout<<"double: "<<e<<endl;        }    }        cout << "Press the enter key to continue ...";    cin.get();    return EXIT_SUCCESS;}

注意：第一，catch后面可以只有类型，没有具体变量，但是当没有变量的时候，catch语句块中就不能获得throw语句抛出的异常参数了！

           第二，对于这样一个try语句块和多个catch语句块的时候，基本数据类型往往是不够用的，所以尽量使用自己通过class关键字定义的类类型！

3.深入异常处理：

   a.c++中的catch语句可以使用...捕获所有类型的异常。catch(...)虽然可以捕获所有类型的异常但却无法得到异常信息。catch(...)一般作为最后一个异常处理块出现。看见代码中的catch就要意识到这里在处理异常情况，而异常是在对应的try中产生的。

   b.在catch语句块中，仍然可以使用throw抛出异常

   c.在catch语句块中，可以使用throw a ， 也可以只使用throw;  当throw后面没有变量也没有数据的时候，是表示要抛出catch语句块接受的异常类型(即在catch(int a)这个语句块中，throw; 就是throw a; 的简写)。所以throw; 这种情况只能在catch语句块中使用，不能在try语句块中使用。同时即使是catch(int)这样的语句块中，使用throw;  在外层的catch(int e)异常处理中，也可以获得e的值，就是最初的那个throw 抛出的值！应该是编译器自动提供了一个中间变量！

   d.注意在，catch(...)中的throw;  可以直接把接收到的异常再次抛出！应该也是编译器自动提供了中间变量！

示例代码：

#include <cstdlib>#include <iostream>using namespace std;int test(int i){    if( i == 1 )    {        throw -1;    }        if( i == 2 )    {        throw "ERROR";    }        if( i == 3 )    {        throw 0.5;    }        if( i == 4 )    {        throw 'd';    }        return i;}int main(int argc, char *argv[]){    for(int i=0; i<5; i++)    {       try    {try        {            cout<<test(i)<<endl;        }       catch(int)        {            //cout<<"Int: "<<e<<endl;            throw;        }        catch(const char* e)        {            cout<<"const char*: "<<e<<endl;            throw 3;        }        catch(double e)        {            cout<<"double: "<<e<<endl;            throw;        }        catch(...){cout << "catch(...) " << endl;throw;} }catch(double a){cout << "throw catch(double) " << endl;}catch(int a){cout << "throw catch(int) " << endl;cout << a << endl;}catch(char a){cout << "throw catch(char) " << endl;}catch(...){cout << "throw catch(...) " << endl;}    }        cout << "Press the enter key to continue ...";    cin.get();    return EXIT_SUCCESS;}

4.异常与对象：

   a.切记，千万不要在构造函数中抛出异常，构造函数中可能会申请系统资源(如new int[5])，而在构造函数中抛出异常则会导致对象构造不完全，对于不完全对象的析构函数是不会被调用的，因此可能会造成资源泄漏！(即析构函数不被调用，析构函数中的delet [] 没有执行，造成内存泄漏)

示例代码：

#include <iostream> using namespace std;class test{public:test(){cout << "test()....." << endl;throw 'a';}~test(){cout << "~test()....." << endl;}};void fun(){try{test t1;}catch(char e){cout << e << endl;}}int main(){fun();return 0;}

注意：上面的对象因为是构造不完全的对象，所以对象的析构函数不被调用！

5.工程中的异常应用：

   a.在工程中会定义一系列的异常类，通过继承可以得到一个异常类族。每个类代表工程中可能出现的一种异常类型！

   b.在工程中可以使用标准库中的异常类，可以将标准库中的异常类作为基类派生新的异常类！

   c.标准库中的异常都是从exception类派生而来的，exception类有两个主要分支，logic_error用于描述程序中出现的逻辑错误，如：传递无效参数。runtime_error用于描述无法预料的事件所造成的错误，如：内存耗尽、硬件错误等。

标准库中的异常如图：

   d.标准库中的异常族包含在<stdexcept>头文件中！

   e.logic_error和runtime_error都提供了一个参数为字符串的构造函数，这样就能够保存异常信息，还可以通过what()成员函数得到异常信息！！！

示例代码：

#include <iostream>#include <stdexcept> //异常族的头文件 using namespace std;double Div(double a, double b){//invalid_argument p("Divide by zero...");   if( (-0.00000001 < b) && ( b < 0.00000001) )   {/*invalid_argument是一个异常类，invalid_argument("Divide by zero...")        是直接调用这个类的构造函数(后面是构造函数的参数，也是异常信息)，此时编译器产生一个临时对象，throw就是抛出了这个临时对象 */throw invalid_argument("Divide by zero..."); //throw p;   }       return  a / b;}int main(){try{cout<<Div(1, 0)<<endl;}//这里使用引用是为了避免由于对象构造与拷贝的开销，使用引用就不会再重新创建一个对象进行拷贝了 catch(invalid_argument& error){cout << error.what() << endl;//通过what成员函数获得异常信息 }return 0;}

注意：在catch语句后，可以使用引用参数，使用引用就避免了对象的构造和拷贝的开销，效率会高些！
使用自己创建的异常对象示例代码：

#include <iostream>#include <stdexcept> //异常族的头文件 using namespace std;class div_zero_error : public logic_error{public:div_zero_error(const char* s) : logic_error(s)//初始化列表~~~ {} };double Div(double a, double b){//div_zero_error p("Divide by zero...");   if( (-0.00000001 < b) && ( b < 0.00000001) )   {/*div_zero_error是一个异常类，div_zero_error("Divide by zero...")        是直接调用这个类的构造函数(后面是构造函数的参数，也是异常信息)，此时编译器产生一个临时对象，throw就是抛出了这个临时对象 */throw div_zero_error("Divide by zero..."); //throw p;    }        return  a / b;}int main(){try{cout<<Div(1, 0)<<endl;}//这里使用引用是为了避免由于对象构造与拷贝的开销，使用引用就不会再重新创建一个对象进行拷贝了 catch(exception& error) //使用exception类型 是为了接受各种类型的异常 {cout << error.what() << endl;//通过what成员函数获得异常信息 }return 0;}

注意：第一，当希望通过标准库中的异常类族派生出自己的异常类的时候，首先要自己定义类并继承基类，这样自己的异常类中就继承了logic_error类的构造函数，这个带参的构造函数(即参数是字符串，用来保存异常信息的)是对应what()成员函数的。所以就出现了这样的语句，div_zero_error(const char* s) : logic_error(s)  这条语句很有意思，这条语句使用了构造函数的初始化参数列表！当创建div_zero_error类对象的时候，先接收构造函数的参数，且保存在s中，不管是从初始化列表的角度看，还是从父类构造函数的角度看，都是先调用logic_error类的构造函数，再调用div_zero_error类的构造函数，此时在调用logic_error类的构造函数的时候，就完成了对异常信息的保存！！！等于说把子类div_zero_error的构造函数的参数赋值给了父类logic_error的构造函数的参数，用于传递异常信息，即div_zero_error的构造函数的参数就是用来接收异常信息的！对于那些标准库中的其他子类，原理依然相同！

            第二，在throw语句中，throw后面的对象，不管是临时对象，还是事先创建好的对象，这个对象在创建的时候一定是带字符串参数的，如：div_zero_error p("Divide by zero...");和div_zero_error("Divide by zero...");   没有参数是编译不过的(这个参数就是异常信息)，因为在创建异常类对象的时候，是需要调用父类logic_error的带字符串参数的构造函数的，所以会报错！当然对于属于标准库中的异常类，依然需要准守这个规则！因为标准库中的异常类的创建过程，跟自己定义的异常类创建的过程是一模一样的！！！只不过一个是库函数帮你写好的，一个是你自己写的，代码是相同的！

             第三，对于工程中的代码，如果已经约定好所有的异常都是基于exception这个基类派生的异常类族，当想接收所有异常的时候，就不用catch(...)这样的语句了，因为catch(...)不能获得what函数的异常信息！可以使用catch(exception& error)这样的语句来捕获所有异常，这里利用的是子类父类之间的赋值兼容性原则(即子类是特殊的父类，exception类可以接收所有他的子类)！

6.函数级try语法：

注意：其实两段代码没有任何区别，仅仅是多一对括号和少一对括号的区别！右侧的代码主要是，怕try语句块中的代码过多，使程序员忘记这是在try语句块中！仅仅是为了提高代码的可读性和维护性！意义并不是很大，遇到了能够认识就可以了！这里有一个问题是要注意的，这种等效关系的前提是，函数的所有正常逻辑的语句全部在try代码块中！！！也就是说函数体除了try代码块，和catch代码块外没有别的语句！