我们的异常处理类的features

如何写一个异常处理类是一个不太容易的事情，最近刚好接触了一些不错的代码，看到了一些技巧，这里和大家分享一下。
一个相对完善的异常处理类（以及附加的一些东西）应该能够处理下面的一些功能：
1） 能够方便的定义异常类的继承树
2） 能够方便的throw、catch，也就是在代码中捕获、处理代码的部分应该更短
3） 能够获取异常出现的源文件的名字、方法的名字、行号
4） 能够获取异常出现的调用栈并且打印出来
由于目前我用的平台是linux，所以里面调用的一些函数也只是在linux下面有用。Windows也肯定是具有相应的函数的，具体可能需要去查查

首先科普一些内容：

1） 对于没有捕获的异常（no handler），则会终止程序，调用terminate()
2） 在定义函数的时候，我们可以在定义的后面加上throw (exception1, exception2…):
a) 如果没有写这一段、则可能抛出任意的异常
b) 如果写throw()，则表示函数不能抛出任意的异常
c) 如果写throw(A, B), 表示函数抛出A、B的异常
如果抛出的异常不在列表范围内，则异常不能被catch，也就会调用terminate()

我们构想一下我们定义、调用我们的异常类的时候是怎样的一个情形：

1） 定义：
    1:
class DerivedException :
public BaseException
    2: {
    3:
public:
    4:     MY_DEFINE_EXCEPTION(DerivedException, BaseException);
    5: };
2） 如何抛出异常
   
1: MY_THROW(DerivedException)
3） 如何catch异常
   
1:
catch (DerivedException& e)
   
2: {
   
3:     cout<< e.what() << endl;
   
4: }
这个输出的内容包括错误的行号、文件名、方法名、和调用栈的列表

给出我们异常类的头文件：

    1: #ifndef EXCEPTION_TEST
    2: #define EXCEPTION_TEST
    3:
    4: #include <exception>
    5: #include <string>
    6:
    7: #define MY_THROW(ExClass, args...)                             \
    8:     do                                                         \
    9:     {                                                          \
   10:         ExClass e(args);                                       \
   11:         e.Init(__FILE__, __PRETTY_FUNCTION__, __LINE__);       \
   12:         throw e;                                               \
   13:     }                                                          \
   14:     while (false)
   15:
   16: #define MY_DEFINE_EXCEPTION(ExClass, Base)                     \
   17:     ExClass(const std::string& msg = "") throw()               \
   18:         : Base(msg)                                            \
   19:     {}                                                         \
   20:                                                                \
   21:     ~ExClass() throw() {}                                        \
   22:                                                                \
   23:     /* override */ std::string GetClassName() const            \
   24:     {                                                          \
   25:         return #ExClass;                                       \
   26:     }
   27:
   28: class ExceptionBase : public std::exception
   29: {
   30: public:
   31:     ExceptionBase(const std::string& msg = "") throw();
   32:
   33:     virtual ~ExceptionBase() throw();
   34:
   35:     void Init(const char* file, const char* func, int line);
   36:
   37:     virtual std::string GetClassName() const;
   38:
   39:     virtual std::string GetMessage() const;
   40:
   41:     const char* what() const throw();
   42:
   43:     const std::string& ToString() const;
   44:
   45:     std::string GetStackTrace() const;
   46:
   47: protected:
   48:     std::string mMsg;
   49:     const char* mFile;
   50:     const char* mFunc;
   51:     int mLine;
   52:
   53: private:
   54:     enum { MAX_STACK_TRACE_SIZE = 50 };
   55:     void* mStackTrace[MAX_STACK_TRACE_SIZE];
   56:     size_t mStackTraceSize;
   57:     mutable std::string mWhat;
   58: };
   59:
   60: class ExceptionDerived : public ExceptionBase
   61: {
   62: public:
   63:     MY_DEFINE_EXCEPTION(ExceptionDerived, ExceptionBase);
   64: };
   65:
   66: #endif
这个头文件首先定义了两个宏，这里先暂时不管他，我先来解释一下ExceptionBase，它继承自std::exception，std::exception里面其实已经提供了一些功能了，但是比较弱，为了实现我们上文提到的功能，这里只是继承了std:exception的借口，也就是what()函数。
上面的接口应该比较好理解，45行的GetStackTrace是打印当前的调用栈，49-51行分别存储了当前出现exception的源文件名，函数名，行号，54行定义了最大的调用栈显示的深度，也就是显示50行。
60行显示了怎样定义一个新的异常类，这个就很方便了，通过MY_DEFINE_EXCEPTION宏去定义了一个继承类，详情见16行，这里不再细说，我这里想说说7行的MY_THROW宏，使用了3个内置的参数，__FILE__, __LINE__, __PRETTY_FUNCTION__, 他们分别是当前的文件名，行号，和函数名，他们的使用方法是在哪儿出现，其相应的值就是什么。
为什么这里要使用MY_THROW宏呢？其实是为了方便的把行号、文件名等加入进来，宏展开的时候是在一行上的，这样也使得行号与出错的行号保持一致，而且让代码更简单。
给出异常类的.cpp文件：
    1: #include <execinfo.h>
    2: #include <stdlib.h>
    3: #include <cxxabi.h>
    4:
    5: #include <iostream>
    6: #include <sstream>
    7:
    8: #include "exception_test.h"
    9:
   10: using namespace std;
   11:
   12: ExceptionBase::ExceptionBase(const std::string& msg) throw()
   13:     : mMsg(msg),
   14:       mFile("<unknown file>"),
   15:       mFunc("<unknown func>"),
   16:       mLine(-1),
   17:       mStackTraceSize(0)
   18: {}
   19:
   20: ExceptionBase::~ExceptionBase() throw()
   21: {}
   22:
   23: void ExceptionBase::Init(const char* file, const char* func, int line)
   24: {
   25:     mFile = file;
   26:     mFunc = func;
   27:     mLine = line;
   28:     mStackTraceSize = backtrace(mStackTrace, MAX_STACK_TRACE_SIZE);
   29: }
   30:
   31: std::string ExceptionBase::GetClassName() const
   32: {
   33:     return "ExceptionBase";
   34: }
   35:
   36: const char* ExceptionBase::what() const throw()
   37: {
   38:     return ToString().c_str();
   39: }
   40:
   41: const std::string& ExceptionBase::ToString() const
   42: {
   43:     if (mWhat.empty())
   44:     {
   45:         stringstream sstr("");
   46:         if (mLine > 0)
   47:         {
   48:             sstr << mFile << "(" << mLine << ")";
   49:         }
   50:         sstr <<  ": " << GetClassName();
   51:         if (!GetMessage().empty())
   52:         {
   53:             sstr << ": " << GetMessage();
   54:         }
   55:         sstr << "\nStack Trace:\n";
   56:         sstr << GetStackTrace();
   57:         mWhat = sstr.str();
   58:     }
   59:     return mWhat;
   60: }
   61:
   62: std::string ExceptionBase::GetMessage() const
   63: {
   64:     return mMsg;
   65: }
   66:
   67: std::string ExceptionBase::GetStackTrace() const
   68: {
   69:     if (mStackTraceSize == 0)
   70:         return "<No stack trace>\n";
   71:     char** strings = backtrace_symbols(mStackTrace, 10);
   72:     if (strings == NULL) // Since this is for debug only thus
   73:                          // non-critical, don't throw an exception.
   74:         return "<Unknown error: backtrace_symbols returned NULL>\n";
   75:
   76:     std::string result;
   77:     for (size_t i = 0; i < mStackTraceSize; ++i)
   78:     {
   79:         std::string mangledName = strings[i];
   80:         std::string::size_type begin = mangledName.find('(');
   81:         std::string::size_type end = mangledName.find('+', begin);
   82:         if (begin == std::string::npos || end == std::string::npos)
   83:         {
   84:             result += mangledName;
   85:             result += '\n';
   86:             continue;
   87:         }
   88:         ++begin;
   89:         int status;
   90:         char* s = abi::__cxa_demangle(mangledName.substr(begin, end-begin).c_str(),
   91:                                       NULL, 0, &status);
   92:         if (status != 0)
   93:         {
   94:             result += mangledName;
   95:             result += '\n';
   96:             continue;
   97:         }
   98:         std::string demangledName(s);
   99:         free(s);
  100:         // Ignore ExceptionBase::Init so the top frame is the
  101:         // user's frame where this exception is thrown
  102:         /
  103:         // Can't just ignore frame#0 because the compiler might
  104:         // inline ExceptionBase::Init.
  105:         result += mangledName.substr(0, begin);
  106:         result += demangledName;
  107:         result += mangledName.substr(end);
  108:         result += '\n';
  109:     }
  110:     free(strings);
  111:     return result;
  112: }
  113:
  114: /*
  115:  * test-main
  116:  */
  117: int f2()
  118: {
  119:     MY_THROW(ExceptionDerived, "f2 throw");
  120: }
  121: void f1()
  122: {
  123:     try
  124:     {
  125:         f2();
  126:     }
  127:     catch (ExceptionDerived& e)
  128:     {
  129:         cout << e.what() << endl;
  130:     }
  131: }
  132: int main()
  133: {
  134:     f1();
  135: }
这是函数的实现代码，其他的都比较好理解，67行的GetStackTrace是相对复杂一点的，里面用backtrace函数去获取了当前调用栈的层数，用backtrace_symbols去获取当前调用栈的符号，而且__cxa_demangle函数的使用也值得去看看，这里不再细说了。
117行后展示了一个测试代码，代码虽然定义比较麻烦，不过使用还是很方便的：）。