65_C++中的异常处理（下）

1. catch语句块中可以抛出异常

• catch中抛出的异常需要外层的try...catch...捕获
  
  

问题： 为什么要在catch中重新抛出异常？
catch中捕获的异常可以被重新解释后抛出，工程开发中使用这样的方式统一异常类型。

编程说明：异常的重新解释示例1

#include 
#include 

using namespace std;

void Demo()
{
    try
    {
        try
        {
            throw 'c';
        }
        catch(int i)
        {
            cout << "Inner: catch(int i)" << endl;
            throw i;
        }
        catch(...)
        {
            cout << "Inner: catch(...)" << endl;
            throw ;
        }
    }
    catch(...)
    {
        cout << "outer: catch(...)" << endl;
    }
}

int main()
{
    Demo();
    
    return 0;
}

输出结果：

Inner: catch(...)
outer: catch(...)

编程说明：异常的重新解释示例2

#include 
#include 

using namespace std;

/*
    假设： 当前的函数是第三方库中的函数，因此，我们无法修改源代码
    
    函数名： void func(int i)
    抛出异常信息： int
                    -1 --> 参数异常
                    -2 --> 运行异常
                    -3 --> 超时异常
*/

void func(int i)
{
    if( i < 0 )
    {
        throw -1;
    }
    
    if( i > 100 )
    {
        throw -2;
    }
    
    if( i == 11 )
    {
        throw -3;
    }
    
    cout << "Run func ..." << endl;
}

void MyFunc(int i)
{
    try
    {
        func(i);
    }
    catch(int i)
    {
        switch(i)
        {
            case -1:
                throw "Invalid Parameter";
                break;
            case -2:
                throw "Runtime Exception";
                break;
            case -3:
                throw "Timeout Exception";
                break;
        }
    }
    catch(...)
    {
        throw ;
    }
}

int main()
{
    try
    {
        MyFunc(11);
    }
    catch(const char* cs)
    {
        cout << "Exception Info: " << cs << endl;
    }
    catch(...)
    {
        cout << "Unknown Exception!!!" << endl;
    }
    
    return 0;
}

输出结果

Exception Info: Timeout Exception

2. 自定义异常类

• 异常的类型可以是自定义类类型
• 对于类类型异常的匹配依旧是至上而下严格匹配
• 赋值兼容性原则在异常匹配中依然适用，即子类的异常情况可以被父类的异常语句块catch到
• 一般原则：
  • 匹配子类异常的catch放在上部
  • 匹配父类异常的catch放在下部
• 在工程中会定义一系列的异常类
• 每个类代表工程中可能出现的一种异常类型
• 代码复用时可能需要重解释不同点的异常类
• 在定义catch语句块时推荐使用引用作为参数，可以避开拷贝构造，提高程序效率

编程说明：类类型的异常

#include 
#include 

using namespace std;

class Base
{

};

class Exception : public Base
{
    int m_id;
    string m_desc;
public:
    Exception(int id, string desc)
    {
        m_id = id;
        m_desc = desc;
    }
    
    int id() const
    {
        return m_id;
    }
    
    string description() const
    {
        return m_desc;
    }
};


/*
    假设： 当前的函数是第三方库中的函数，因此，我们无法修改源代码
    
    函数名： void func(int i)
    抛出异常信息： int
                    -1 --> 参数异常
                    -2 --> 运行异常
                    -3 --> 超时异常
*/

void func(int i)
{
    if( i < 0 )
    {
        throw -1;
    }
    
    if( i > 100 )
    {
        throw -2;
    }
    
    if( i == 11 )
    {
        throw -3;
    }
    
    cout << "Run func ..." << endl;
}

void MyFunc(int i)
{
    try
    {
        func(i);
    }
    catch(int i)
    {
        switch(i)
        {
            case -1:
                throw Exception(-1, "Invalid Parameter");
                break;
            case -2:
                throw Exception(-2, "Runtime Exception");
                break;
            case -3:
                throw Exception(-3, "Timeout Exception");
                break;
        }
    }
    catch(...)
    {
        throw ;
    }
}

int main()
{
    try
    {
        MyFunc(11);
    }
    catch(const Exception& e)
    {
        cout << "Exception Info: " << endl;
        cout << "   Id: " << e.id() << endl;
        cout << "   Description: " << e.description() << endl;
    }
    catch(...)
    {
        cout << "Unknown Exception!!!" << endl;
    }
    
    return 0;
}

输出结果：

Exception Info: 
    Id: -3
    Description: Timeout Exception

3. STL中的异常类

• C++标准库（STL）中提供了实用异常类族
• SLT中的异常都是从exception类派生的
• exception类有两个主要的分支：
  • logic_error：常用于程序中的可避免逻辑错误
  • runtime_error：常用于程序中无法避免的恶性错误
    
    

编程说明：STL中的异常使用

补充

4. 小结

• catch语句块中可以抛出异常
• 异常的类型可以是自定义类类型
• 赋值兼容性原则在异常匹配中依然适用
• 标准库中的异常都是从exception类派生的