＜八＞异常机制

异常机制
• 异常是程序库(library)和应用(application)针对违例的通知机制
• throw 抛出异常, try 包含可能抛异常的语句块，catch 语句捕获异常
• catch 异常对象时，使用引用避免异常对象拷贝。
• 无论异常是否出现，函数调用栈上的对象会确保释放（析构函数）

• C++11废弃了异常规约（列举函数可能抛出的异常），而采用noexcept表示是否抛出异常
• 只有确定不抛异常的函数才标记noexcept
• 如果函数标记为noexcept又抛出异常，则程序立即终止。

什么情况使用异常机制?
• 错误罕见无预期、直接调用者无法处理（必须层层交给最终调用者）
• 错误码没有合适路径返回、或者返回错误码低效、混乱

什么情况使用返回错误码？
错误是常规预期会出现的、并且调用者能够合理处理（例如文件打开错误）

double process1(int a, int b) {

    MyClass *mc =new MyClass();

   if( b <= 0 ) {
        MyException mexp("argument b mush be greater than 0")
        throw mexp;
   }
   delete mc; //抛出的异常可能会导致内存异常, 改进如下面版本,可以避免内存溢出情况
   return (a/b);

}

double process2(int a, int b) {
   MyClass mc ;
   if( b <= 0 ) {
        MyException mexp("argument b mush be greater than 0")
        throw mexp;
   }   
   return (a/b);  

}

class MyClass1{
public:

    MyClass1(){
        invalid_argument exp("MyClass1 Ctor Exception");
        throw exp;
        cout<<"MyClass 1 初始化"<<endl;
    }

    ~MyClass1(){
        cout<<"MyClass 1 析构"<<endl;
    }
    
};

class MyClass2{
public:
    MyClass2(){
        cout<<"MyClass 2 初始化"<<endl;
    }

    ~MyClass2(){
        cout<<"MyClass 2 析构"<<endl;
    }

};

class BigClass{
    MyClass2 mc2;  // mc2正确初始化了,也能正确析构 mc2如果构造好了，RAII仍然会保证mc2的析构
    MyClass1 mc1;
};

void process()
{
    cout<<"start process"<<endl;
    BigClass bc;
    cout<<"end process"<<endl;
}
int main() {
    try {
        process();   
   } catch(invalid_argument& e) {
       cerr<<"invalid arg: " << e.what()<<endl;
   }
}

mc2正确初始化了, MyClass1 mc1 即使构造抛异常,也能正确析构 mc2 ，RAII仍然会保证mc2的析构


// ----------------看看另一个版本的问题, 如下------------------

class MyClass1{
public:

    MyClass1(){
        invalid_argument exp("MyClass1 Ctor Exception");
        throw exp;
        cout<<"MyClass 1 初始化"<<endl;
    }

    ~MyClass1(){
        cout<<"MyClass 1 析构"<<endl;
    }
    
};

class MyClass2{
public:
    MyClass2(){
        cout<<"MyClass 2 初始化"<<endl;
    }

    ~MyClass2(){
        cout<<"MyClass 2 析构"<<endl;
    }

};

class BigClass{
public:
    BigClass()
    {
      cout<<"BigClass ctor"<<endl;
      mc2=new MyClass2;
      mc1=new MyClass1;
    }
    ~BigClass()
    {
       cout<<"~BigClass dctor"<<endl;
       delete mc2;
       delete mc1;
    }
private:
    MyClass2 *mc2;  // mc2正确初始化了,也能正确析构 mc2如果构造好了，RAII仍然会保证mc2的析构
    MyClass1 *mc1;
};

void process()
{
    cout<<"start process"<<endl;
    BigClass bc;
    cout<<"end process"<<endl;
}
int main() {
    try {
        process();   
   } catch(invalid_argument& e) {
       cerr<<"invalid arg: " << e.what()<<endl;
   }
}


上面的代码 BigClass 的构造函数中 mc2正常构造, mc1构造是发生异常, BigClass 析构执行不到,mc2内存
未能正常是否!!!!!有内存泄露, 比较常见且隐蔽的内存泄露

但是将
MyClass2  * mc2;
MyClass1  * mc1;
换成
MyClass2  mc2;
MyClass1  mc1; 就没有问题

性能指南——异常处理

• 使用RAII，尽量避免对try/catch 的显式使用

• 将不抛异常的函数声明为noexcept，是很多代码优化的前提
编译器优化可以省掉展开栈的相关成本
只有移动操作不抛出异常，才使用移动；否则使用拷贝替代
针对异常中立的函数（自己不抛，但调用的函数可能会抛），不要试图捕获所有异常，来实现noexcept
默认情况下，内存释放函数、析构函数为noexcept

• 只要启用异常，代码一般会有5%～15%的膨胀
• 异常不抛出时没有额外性能负担，只有抛出时才有（比错误码大）
• 只有特殊的硬实时系统对时间开销（异常抛出时），或者嵌入式系统对空间开销（代码膨胀）极度敏感时，才关闭异常（决策前测量）