C++异常处理

要点

• 异常根据抛出的类型捕获，可以直接捕获接收或通过引用接收。但二者同时只能存在一个。
• 栈内存创建的对象指针抛出后会产生野指针问题
• 动态创建对象的指针抛出后可以正常捕获使用，但是需要手动释放。
• 函数声明可以加上异常声明。限制函数可以抛出的异常类型。
• 异常有栈解锁机制，栈内存中创建的对象在异常抛出后会自动析构。
• 异常可以捕获并继续向上抛出。

示例代码

#include "stdafx.h"
#include "iostream"
#include "string.h"
using namespace std;
#pragma warning(disable : 4996)  
class ExceptionA {
private:
    char *msg;
public:
    ExceptionA(const char *msg) {
        cout << "构造" <<msg<< endl;
        if (msg == NULL) {
            this->msg = NULL;
        }else{
            this->msg = new char[strlen(msg) + 1];
            strcpy(this->msg, msg);
        }
    }
    char * getMsg()const {
        return this->msg;
    }
    ExceptionA(const ExceptionA& e) {
        cout << "拷贝构造" << endl;
        if (this->msg == NULL) {
            delete[]this->msg;
        }
        this->msg = new char[strlen(e.getMsg()) + 1];
        strcpy(this->msg, e.getMsg());
    }
    ~ExceptionA() {
        cout << "析构" << msg << endl;
        if (this->msg != NULL) {
            delete[]this->msg;
        }
    }
};

void funcA(int x) {

    switch (x)
    {
    case 0:{
        //throw异常后，temp1会自动析构，而temp不会自动析构和释放
        ExceptionA *temp = new ExceptionA("temp");
        ExceptionA temp1("temp1");
        throw 1;
    }
        break;
    case 1:
        throw 'a';
        break;
    case 2:
        //可以直接接受或使用引用接收。推荐使用引用接收
        throw(ExceptionA("msg 2"));
        break;
    case 3:
        //抛出指针，但对象会被清理。catch到的指针是野指针
        throw(&ExceptionA("msg 3"));
        break;
    case 4: {
        //抛出动态分配的指针。catch到后使用完后需要delete
        ExceptionA* e = new ExceptionA("msg4");
        throw(e);
    }
        break;
    case 5:
        throw 3.14f;
    case 6:
        throw 3.14;
    }
    cout << "funcA success " << x << endl;
}

void funcB(int index) throw(float ,double){
    try {
        funcA(index);
    }
    catch (int e) {
        cout << "catch int " << e << endl;
    }
    catch (char e) {
        cout << "catch char " << e << endl;
    }
    catch (ExceptionA e) {
        cout << "catch  ExceptionA " << e.getMsg() << endl;
    }
    //使用对象接收和使用对象的引用接收不能同时存在。
    //catch (ExceptionA &e) {
    //  cout << "catch  ExceptionA & " << e.getMsg() << endl;
    //}
    catch (ExceptionA *e) {
        cout << "catch  ExceptionA * " << e->getMsg() << endl;
        delete e;
    }
    catch (float e) {
        //接续向上抛出异常
        cout << "catch float and throw  " << e << endl;
        throw e;
    }
    catch (double e) {
        //接续向上抛出异常，但函数的方法上有限制可以抛出异常的类型。这里会出错
        cout << "catch double and throw  " << e << endl;
        throw e;
    }
}
int main()
{
    try {
        funcB(6);
    }
    catch (float e) {
        cout << "main catch " << e << endl;
    }
    return 0;
}

异常处理场景演示

• funcB(0)

  
  0.png
  

  这里创建了两个对象一个在堆中动态创建temp.一个在栈中temp1。执行结果看到temp1自动被析构，而temp未被析构。c++在异常抛出后有栈解锁机制，会自动析构在栈中创建的对象。

• funcB(1)

  
  1.png
  

  这里就是按类型在funcA中正常的catch

• funcB(2) 栈内存对象

  • 用对象直接接收

    
    2.png
    

    这里看到当抛出对象时候，catch中接受时类似方法实参到形参的传递，进行拷贝构造。

  • 用对象的引用接收

    
    7.png
    

    catch中得到对象的引用。

• funcB(3) 抛出栈内存对象的指针

  
  3
  

  catch得到对象的指针前。对象已被析构，这里得到的就是野指针。

• funcB(4) 动态创建对象

  
  4.png
  

  可以正常catch到并使用。但使用完后需要手动释放。

• funcB(5) 捕获到异常后继续向上抛出

  
  5.png
  

  funcA中继续抛出，在main中正常捕获。

• funcB(6) 方法异常类型声明

  
  6.png
  

  限制方法能够抛出异常的类型，如果不在范围内，运行会报错