抛出异常

• 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;
}