抛出异常

• throw 异常对象
• 可以抛出基本类型的对象，如:throw -1;throw "内存分配失败!";
• 也可以抛出类类型的对象，如:MemoryException ex;throw ex;throw MemoryException();
• 但不要抛出局部对象的指针，如:MemoryException ex;throw &ex; // 错误!

捕获异常

try {
可能引发异常的语句
}
catch (异常类型1& ex){针对异常类型1的异常处理;}
catch (异常类型2& ex) {针对异常类型2的异常处理;}
...
catch (异常类型n& ex) {针对异常类型n的异常处理;}

未抛出异常时的流程

抛出异常时的流程

捕获异常

• 建议在catch子句中使用引用接收异常对象，避免因为拷贝构造带来性能损失
• 推荐以匿名临时对象的形式抛出异常
• 异常对象必须允许被拷贝构造和析构

匹配顺序

根据异常对象的类型自上至下顺序匹配，而非最优匹配，因此对子类类型异常的捕获不要放在对基类类型异常的捕获后面

异常说明

异常说明是函数原型的一部分，旨在说明函数可能抛出的异常类型
返回类型 函数名(形参表) throw (异常类型1，异常类型2,...) {函数体;}

异常说明是一种承诺，承诺函数不会抛出异常说明以外的异常类型
如果函数抛出了异常说明以外的异常类型，那么该异常将无法被捕获并导致进程中止

隐式抛出异常的函数也可以列出它的异常说明

异常说明可以没有也可以为空

• 没有异常说明，表示可能抛出任何类型的异常
  • void foo (void) { ... }
• 异常说明为空，表示不会抛出任何类型的异常
  • void foo (void) throw () { ... }

异常说明在函数的声明和定义中必须保持严格一致，否则将导致编译错误

异常处理

• 可以抛出基本类型的异常
• 可以抛出类类型的异常
• 利用类类型的异常，携带更多诊断信息，以便查错
• 可以在catch块中继续抛出所捕获的异常，或其它异常
• 任何未被捕获的异常，默认的处理方式就是中止进程
• 忽略异常，不做处理

构造函数中的异常

构造函数可以抛出异常，某些时候还必须抛出异常

• 构造过程中可能遇到各种错误，比如内存分配失败
• 构造函数没有返回值，无法通过返回值通知调用者

构造函数抛出异常，对象将被不完整构造，而一个被不完整构造的对象，其析构函数永远不会被执行

• 所有对象形式的成员变量，在抛出异常的瞬间，都能得到正确地析构 (构造函数的回滚机制)
• 所有动态分配的资源，必须在抛出异常之前，自己手动释放，否则将形成资源的泄漏

析构函数中的异常

不要从析构函数中主动抛出异常

在两种情况下，析构函数会被调用

• 正常销毁对象，离开作用域或显式delete
• 在异常传递的堆栈辗转开解(stack-unwinding)过程中

对于第二种情况，异常正处于激活状态，而析构函数又抛出了异常这时C++将通过std::terminate()函数，令进程中止
对于可能引发异常的操作，尽量在析构函数内部消化
try {... }catch (...) { ... }

标准库异常类

// 利用return报告异常信息
#include <iostream>
#include <cstdio>
using namespace std;

class A{
public:
    A() {  cout << "A()被调用" << endl; }
    ~A(){  cout << "~A()被调用" << endl; }
};


void foo(){
    cout << "foo出错前的几百行代码" << endl;
    A a;
    FILE* pfile = fopen("./cfg","r");
    if(!pfile)
        throw -1;
    cout << "foo出错后的几百行代码" << endl;
} // a.~A() 释放a本身所占内存空间

void bar(){
    cout << "bar出错前的几百行代码" << endl;
    A b;
//    try{
        foo();
//    }
//    catch(int e){
//        cout << "bar函数中捕获异常信息: " << e << endl;
//    }
    cout << "bar出错后的几百行代码" << endl;
} // b.~A() 释放b本身所占内存空间

void hum(){
    cout << "hum出错前的几百行代码" << endl;
    A c;
    try{
        bar();
    }
    catch(int e){
        cout << "hum函数中捕获异常信息：" << e << endl;
    }
    cout << "bar出错后的几百行代码" << endl;
} // c.~A() 释放c本身所占内存空间


int main( void ){
    cout << "main出错前的几百行代码" << endl;
    A d;
    hum();
    cout << "main出错后的几百行代码" << endl;
    return 0;
} // d.~A() 释放d本身所占内存空间

// 建议将子类类型异常捕获放到基类类型异常捕获的前面
#include <iostream>
using namespace std;

class A{};

class B : public A{};



void foo(){
    throw B();
}

int main( void ){
    try{
        foo();
    }
    catch(B& b){  
        cout << "B类型catch捕获" << endl;
    }
    catch(A& a){  
        cout << "A类型catch捕获" << endl;
    }
    return 0;
} 

// 没有异常说明和异常说明为空
#include <iostream>
using namespace std;

void foo()  { // 没有异常说明：函数内部可能抛出任何类型的异常
    throw  "Hello world!"; // 3.14; // -1;
}

void bar() throw(){ // 异常说明为空：承诺函数内部绝对不会抛出任何类型的异常
//  throw -1;
}
// 异常说明在声明和定义时必须严格一致，否则将报编译错误
void hum() throw(int,double);  // 声明
void hum() throw(int,double){ // 定义
}




int main( void ){
    try{
       foo();
//     bar();
    }
    catch( ... ){ // 忽略异常
        // ...
    }

/*    catch(int& e){
        cout << "1. 捕获异常信息："<< e << endl; 
    }
    catch(double& e){
        cout << "2. 捕获异常信息：" << e << endl;
    }
    catch(const char* e){
        cout << "3. 捕获异常信息：" << e << endl;
    }*/
    return 0;
} 

// 构造函数中的异常
#include <iostream>
#include <cstdio>
using namespace std;

class A{
public:
    A(){ cout << "A()被调用" << endl; }
    ~A(){ cout << "~A()被调用" << endl; }
};
class C{
public:
    C():m_p(new int){
        //【A m_a;】定义m_a,利用m_a.A()
        //【int* m_p = new int;】定义m_p,初值指向一块堆内存(动态资源)
        cout << "C()被调用" << endl;
        FILE* pfile = fopen("./cfg","r");
        if(!pfile){
            delete m_p; // 需要自己手动释放
            // 对于m_a.利用m_a.~A()
            // 释放m_a/m_p本身所占内存空间
            throw -1;
        }
        // ....构造函数中后续代码...
    }
    ~C(){
        delete m_p;
        cout << "~C()被调用" << endl;
        // 对于m_a.利用m_a.~A()
        // 释放m_a/m_p本身所占内存空间
    }
private:
    A m_a;
    int* m_p;
};


int main( void ){
    try{
        C c; // 定义c,利用c.C();
    }// 如果c是完整构造对象，将利用c.~C(),但是如果c是残缺对象，就不会调用~C()
    catch( ... ){
        // ...
    }
    return 0;
}