C++中的异常

　　我们先看一下异常跟断言的区别：　

　　“ 

　　异常被捕获后可以不作处理，程序从捕获位置继续执行。而断言是完全无法忽略的，程序在断言失败处立即终止。因此断言通常用于调试版本，用来发现程序中的逻辑错误。虽然异常也能起到这样的作用，但是不应该用异常代替断言：
　　1) 如果发现了逻辑错误，必须修改程序，而不可能在程序中进行处理和恢复，所以不需要向外传送，没有必要使用异常。
　　2) 使用断言的开销比异常小得多，而且断言可以从发布版中完全去除。

　　异常用于处理正确程序中的运行期问题(比如内存分配失败，窗口创建失败，线程创建失败，打开文件失败)，以尽可能恢复，而不是终止程序。对于运行异常，使用断言是非常不合适的，理由很显然：
　　1) 断言在发布版不起作用；
　　2) 断言的处理方式不够友好；
　　3) 运行异常不是程序错误，没有必要报告源代码出错位置。

　　” 

一个简单例子及catch(...)的作用

#include <iostream>
#include <stdlib.h>

using namespace std;

double func(double x, double y)
{
    if (y == 0)
    {
        throw y;        // 抛出异常
    }
    return x / y;
}

int main()
{
    double res;
    try
    {
        res = func(2, 3);
        cout << "The result of x/y is : " << res << endl;
        res = func(4, 0);
    }
    catch (double)        // 捕获异常
    {
        cerr << "error of dividing zero.
" << endl;;
        exit(1);
    }
    catch (...)            // 类似于switch case语句中会用到的的default语句
    {
        cerr << "exception occurs" << endl;
    }

    return 0;
}

　　catch(…)能够捕获多种数据类型的异常对象，所以它提供给程序员一种对异常对象更好的控制手段，使开发的软件系统有很好的可靠性。因此一个比较有经验的程序员通常会这样组织编写它的代码模块，如下：

void Func()
{
    try
    {
        // 这里的程序代码完成真正复杂的计算工作，这些代码在执行过程中
        // 有可能抛出DataType1、DataType2和DataType3类型的异常对象。
    }
    catch (DataType1& d1)
    {
    }
    catch (DataType2& d2)
    {
    }
    catch (DataType3& d3)
    {
    }
    // 注意上面try block中可能抛出的DataType1、DataType2和DataType3三
    // 种类型的异常对象在前面都已经有对应的catch block来处理。但为什么
    // 还要在最后再定义一个catch(…) block呢？这就是为了有更好的安全性和
    // 可靠性，避免上面的try block抛出了其它未考虑到的异常对象时导致的程
    // 序出现意外崩溃的严重后果，而且这在用VC开发的系统上更特别有效，因
    // 为catch(…)能捕获系统出现的异常，而系统异常往往令程序员头痛了，现
    // 在系统一般都比较复杂，而且由很多人共同开发，一不小心就会导致一个
    // 指针变量指向了其它非法区域，结果意外灾难不幸发生了。catch(…)为这种
    // 潜在的隐患提供了一种有效的补救措施。
    catch (…)
    {
    }
}

异常中采用面向对象的处理

　　先看个例子

#include <iostream>
#include <exception>

using namespace std;

class ExceptionClass
{
public:

    ExceptionClass(char * name = "Exception Default Class")
    {
        cout << "Exception Class : Construct String" << endl;
    }

    virtual ~ExceptionClass()
    {
        cout << "Exception Class : Destruct String" << endl;
    }

    void ReportError()
    {
        cout << "Exception Class : Report Error Message" << endl;
    }

};

class TestedClass
{
public:

    TestedClass(char * name = "dufault name")
    {
        cout << "Construct String::" << name << endl;
        this->name = name;
    }

    virtual ~TestedClass()
    {
        cout << "Destruct String" << endl;
    }

    void mythrow()
    {
        throw ExceptionClass("my throw");
    }

private:
    char * name;

};

int main()
{
    TestedClass e("Test");
    try
    {
        e.mythrow();
    }
    catch (ExceptionClass eTestedClass)
    {
        eTestedClass.ReportError();
    }
    catch (...)
    {
        cout << "*******************" << endl;
    }

    return 0;
}

　　在该例子中专门设计了一个异常类来处理异常。

　　在博文“C++的try_catch异常”中，作者还提供了另一个很值得参考的例子。

void OpenFile(string f)
{
    try
    {
        // 打开文件的操作，可能抛出FileOpenException
    }
    catch (FileOpenException& fe)
    {
        // 处理这个异常，如果这个异常可以很好的得以恢复，那么处理完毕后函数
        // 正常返回；否则必须重新抛出这个异常，以供上层的调用函数来能再次处
        // 理这个异常对象
        int result = ReOpenFile(f);
        if (result == false) throw;
    }
}

void ReadFile(File f)
{
    try
    {
        // 从文件中读数据，可能抛出FileReadException
    }
    catch (FileReadException& fe)
    {
        // 处理这个异常，如果这个异常可以很好的得以恢复，那么处理完毕后函数
        // 正常返回；否则必须重新抛出这个异常，以供上层的调用函数来能再次处
        // 理这个异常对象
        int result = ReReadFile(f);
        if (result == false) throw;
    }
}

void WriteFile(File f)
{
    try
    {
        // 往文件中写数据，可能抛出FileWriteException
    }
    catch (FileWriteException& fe)
    {
        // 处理这个异常，如果这个异常可以很好的得以恢复，那么处理完毕后函数
        // 正常返回；否则必须重新抛出这个异常，以供上层的调用函数来能再次处理这个异常对象
        int result = ReWriteFile(f);
        if (result == false) throw;
    }
}

void Func()
{
    try
    {
        // 对文件进行操作，可能出现FileWriteException、FileWriteException
        // 和FileWriteException异常
        OpenFile(…);
        ReadFile(…);
        WriteFile(…);
    }
    // 注意：FileException是FileOpenException、FileReadException和FileWriteException
    // 的基类，因此这里定义的catch(FileException& fe)能捕获所有与文件操作失败的异
    // 常。
    catch (FileException& fe)
    {
        ExceptionInfo* ef = fe.GetExceptionInfo();
        cout << “操作文件时出现了不可恢复的错误，原因是：” << fe << endl;
    }
}

构造和析构函数中的异常抛出

　　先看个例子：

#include <iostream>
#include <stdlib.h>

using namespace std;

class ExceptionClass
{
public:

    ExceptionClass()
    {
        cout << "Construct." << endl;
        s = new char[4];
        cout << "Throw a exception." << endl;
        throw 18;
    }
    ~ExceptionClass()
    {
        cout << "Destruct." << endl;
        delete[] s;
    }

private:

    char* s;

};

void main()
{
    try
    {
        ExceptionClass e;
    }
    catch (...)
    {
    }
}

　　程序运行结果为：

　　Construct.

　　Throw a exception.

　　在这两句输出之间，我们已经给 s 分配了内存，但内存没有被释放（因为它是在析构函数中释放的）。应该说这符合实际现象，因为对象没有完整构造。

　　为了避免这种情况，我想你也许会说：应避免对象通过本身的构造函数涉及到异常抛出。即：既不在构造函数中出现异常抛出，也不应在构造函数调用的一切东西中出现异常抛出。但是在C++中可以在构造函数中抛出异常，经典的解决方案是使用STL的标准类unique_ptr。

　　那么，在析构函数中的情况呢？我们已经知道，异常抛出之后，就要调用本身的析构函数，如果这析构函数中还有异常抛出的话，则已存在的异常尚未被捕获，会导致异常捕捉不到。

标准C++异常类

　　标准异常都派生自一个公共的基类exception。基类包含必要的多态性函数提供异常描述，可以被重载。下面是exception类的原型：

class exception 
{
public:
    exception() throw();
    exception(const exception&) throw();
    exception& operator= (const exception&) throw();
    virtual ~exception() throw();
    virtual const char* what() const throw();
};

　　其他派生自基类exception的标准异常类为：

namespace std
{
    //exception派生
    class logic_error;         //逻辑错误,在程序运行前可以检测出来

    //logic_error派生
    class domain_error;        //违反了前置条件
    class invalid_argument; 　　//指出函数的一个无效参数
    class length_error;        //指出有一个超过类型size_t的最大可表现值长度的对象的企图
    class out_of_range;        //参数越界
    class bad_cast;            //在运行时类型识别中有一个无效的dynamic_cast表达式
    class bad_typeid;        　//报告在表达试typeid(*p)中有一个空指针p

    //exception派生
    class runtime_error;    　 //运行时错误,仅在程序运行中检测到

    //runtime_error派生
    class range_error;         //违反后置条件
    class overflow_error;      //报告一个算术溢出
    class bad_alloc;           //存储分配错误

}

　　一个利用标准异常类的例子如下：

#include <iostream>
#include <exception>

using namespace std;

class TestedClass
{
public:

    TestedClass(char * name = "dufault name")
    {
        cout << "Construct String::" << name << endl;
        this->name = name;
    }

    virtual ~TestedClass()
    {
        cout << "Destruct String" << endl;
    }

    void mythrow()
    {
        throw logic_error("my throw");
    }

private:
    char * name;

};

int main()
{
    TestedClass e("Test");
    try
    {
        e.mythrow();
    }
    catch (logic_error& e)
    {
        cerr << "logic error exception caught: " << e.what() << endl;
    }
    catch (exception& e)
    {
        cerr << "exception caught!" << e.what() << endl;
    }
    catch (...)
    {
        cout << "*******************" << endl;
    }

    return 0;
}

参考资料

　　C++的try_catch异常