C++异常探秘（一）

C语言的老手对以下这种代码风格并不陌生

void setName(char* name)
{
    if (!name)
    {
        printf("NULL pointer [%s] [%d]". __FILE__, __LINE__);
        return;
    }
}

当输入参数是NULL的时候，打印一条错误信息，并且返回。不过这样做会有一些问题，比如说代码写的比较啰嗦，如果一个工程中到处都是这种判断错误的代码，那么代码膨胀的比较厉害。让我们看一个简单的exception的例子

#include "stdafx.h"
#include <stdio.h>
#include <iostream>
#include <vector>
#include <string>
#include <stdexcept>

using namespace std;

class MyError : public exception
{
    string ErrorName;
public:
    MyError(string aErrorName)
        : ErrorName(aErrorName)
    {
        cout << "MyError() called" << endl;
    }
    virtual ~MyError()
    {
        cout << "~MyError() called" << endl;
    }
    string what()
    {
        return ErrorName;
    }
};

void testException(char* input)
{
    try
    {
        if (!input)
        {
            throw MyError("NULL input in testException");
        }
    }
    catch (MyError& aError)
    {
        cout << aError.what() << endl;
    }
    catch (...)
    {
        cout << "Exception caught in testException()" << endl;
    }
}

int _tmain(int argc, _TCHAR* argv[])
{
    testException(NULL);
    system("pause");
    return 0;
}

第10行定义一个类MyError，里面存储一个记录异常信息的字符串，第35行抛出MyError类型的异常，第38行捕获MyError类型的异常，如果捕获成功则打印异常信息what()；如果抛出的异常不是MyError类型，则第42行的catch (...)形式的代码将发挥作用，"..."代表即将捕获的异常类型是任意类型的。win32上运行程序，打印输出如下所示
MyError() called
~MyError() called
NULL input in testException
~MyError() called
如果抛出异常而没被捕获会发生什么呢？让我们做个实验，把testException函数改一下，在第一个catch里面加上一行代码throw，这种后面紧跟分号，并且出现在catch中的throw表明程序在重新抛出异常，这个异常将无法被本身的try...catch所捕获。

void testException(char* input)
{
    try
    {
        if (!input)
        {
            throw MyError("NULL input in testException");
        }
    }
    catch (MyError& aError)
    {
        cout << aError.what() << endl;
       throw;
    }
    catch (...)
    {
        cout << "Exception caught in testException()" << endl;
    }
}

运行程序，会看到程序被终止了，这是因为程序遇到了一个没有被捕获的异常，则调用了abort()。

到目前为止，我们了解了关于异常的一些基本知识，但事实上，我们并未触及C++异常的精髓部分，下面让我们看一个例子，

#include "stdafx.h"
#include <stdio.h>
#include <iostream>
#include <vector>
#include <string>
#include <stdexcept>

using namespace std;

class Name
{
    char * name;
    size_t mySize;
public:
    Name(char* pName, size_t size) : mySize(size)
    {
        cout << "CTOR of Name() called" << endl;
        name = new char[size];
        for (char * p1 = pName, * p2 = name; size > 0; size--)
            *p2++ = *p1++;
    }
    virtual ~Name()
    {
        cout << "DTOR of Name() called" << endl;
        delete []name;
    }
    void print()
    {
        size_t aSize = mySize;
        for (char* p = name; aSize > 0; aSize--)
            cout << *p++;
    }
};

void testException(char* input)
{
    try
    {
        char myName[] = "Michael";
        Name *aName = new Name(myName, sizeof(myName));
        aName->print();
        if (!input)
        {
            throw runtime_error("NULL input");
        }
    }
    catch (...)
    {
        cout << "Exception caught in testException()" << endl;
    }
}

int _tmain(int argc, _TCHAR* argv[])
{
    testException(NULL);
    system("pause");
    return 0;
}

第40行new一个Name的对象，aName指向这个对象，第44行抛出异常，然后程序直接跳转到第49行，以下是程序的输出，
CTOR of Name() called
Michael
我们看到，Name类本身的析构函数没有被调用，而这也就意味着内存发生了泄露！这是C/C++程序员最不愿因看到的。尤其在大型的项目上，追查一个内存泄露bug经常要耗费数日。好吧，那我们看看如何避免这类问题的发生呢？最简单的办法是把testException函数做一个小小的改动，在抛出异常之前delete aName，

void testException(char* input)
{
    try
    {
        char myName[] = "Michael";
        Name *aName = new Name(myName, sizeof(myName));
        aName->print();
        if (!input)
        {
            delete aName;
            throw runtime_error("NULL input");
        }
    }
    catch (...)
    {
        cout << "Exception caught in testException()" << endl;
    }
}

这样程序的输出就变为
CTOR of Name() called
Michael DTOR of Name() called
这样就避免了内存泄露。

如果异常发生在构造函数内（因为C++的构造函数没有返回值，因此构造函数里抛出异常时非常常见的），那么会如何呢？其实道理都是一样的，一旦发生异常，那程序会直接跳转到catch这个异常的地方，当然也就不会调用析构函数了，因此在构造函数内异常抛出的地方之前如果发生过new操作，那么一定要在抛异常之前调用相应的delete进行内存释放，不过程序员们经常会遗漏delete，那有没有什么好的方法彻底杜绝内存泄露呢？
当然有，看下面这个例子，

void testException(char* input)
{
    try
    {
        char myName[] = "Michael";
        shared_ptr<Name> aName(new Name(myName, sizeof(myName)));
        aName->print();
        if (!input)
        {
            throw runtime_error("NULL input");
        }
    }
    catch (...)
    {
        cout << "Exception caught in testException()" << endl;
    }
}

这个例子中使用了shared_ptr，c++的智能指针（使用shared_ptr请记得包含头文件），shared_ptr非常强大，这里不做详细说明了，使用shared_ptr的话，把需要定义的类对象（在这里是Name类）当做模板的class T传入，然后在定义对象的后面的括号里new就可以了，使用这种智能指针最大的好处在于，程序员不需要再去关心new以后的delete了，因为shared_ptr里面封装了一套机制，当程序运行脱离了现有的作用域的时候，会自动delete之前new的对象。