异常类Exception

Exception.h

#ifndef EXCEPTION_H
#define EXCEPTION_H
#include <string>
#include <exception>


class Exception : public std::exception
{
public:
    explicit Exception(const char *what);
    explicit Exception(const std::string &what);
    virtual ~Exception() throw();
    virtual const char *what() const throw();
    const char *stackTrace() const throw();

private:
    void fillStackTrace();

    std::string demangle(const char *symbol);
    std::string _message;
    std::string _stack;
};




#endif

Exception.cpp

#include "execption.h"
#include <cxxabi.h>
#include <execinfo.h>
#include <stdlib.h>
#include <stdio.h>

using namespace std;

Exception::Exception(const char *what)
    :_message(what)
{
    fillStackTrace();
}

Exception::Exception(const std::string &what)
    :_message(what)
{
    fillStackTrace();
}

Exception::~Exception() throw()
{

}

const char *Exception::what() const throw()
{
    return _message.c_str();
}

const char *Exception::stackTrace() const throw()
{
    return _stack.c_str();
}

void Exception::fillStackTrace()
{
    const int len = 200;
    void *buffer[len];
    int nptrs = ::backtrace(buffer, len);

    char **strings = ::backtrace_symbols(buffer, nptrs);

    if(strings)
    {
        for(int i = 0; i != nptrs; ++ i)
        {
            _stack.append(demangle(strings[i]));
            _stack.push_back('
');
        }
        free(strings);
    }
}


string Exception::demangle(const char *symbol)
{
    size_t size;
    int status;
    char tmp[128];
    char *demangled;

    if(1 == sscanf(symbol, "%*[^(]%*[^_]%127[^)+]", tmp))
    {
        if(NULL != (demangled = abi::__cxa_demangle(tmp, NULL, &size, &status)))
        {
            string result(demangled);
            free(demangled);
            return result;
        }
    }

    if(1 == sscanf(symbol, "%127s", tmp))
    {
        return tmp;
    }

    return symbol;
}

测试代码:

#include "Exception.h"
#include <stdio.h>

using namespace std;

class Bar
{
    public:
        void test()
        {
            throw Exception("oops");
        }
};

void foo()
{
    Bar b;
    b.test();
}


int main(int argc, const char *argv[])
{
    
    try
    {
        foo();
    }
    catch(const Exception &ex)
    {
        printf("reason : %s
", ex.what());
        printf("stack trace : %s 
", ex.stackTrace());
    }
    return 0;
}

显示结果如下:

reason : oops
stack trace : Exception::fillStackTrace()
Exception::Exception(char const*)
Bar::test()
foo()
./a.out(main+0x10)
/lib/libc.so.6(__libc_start_main+0xe6)
./a.out()

编译时不要忘记 : 加上-rdynamic

有了这个类，我们可以在程序中这样处理异常:

try
    {
        //
    }
    catch(const Exception &ex)
    {
        fprintf(stderr, "reason: %s
", ex.what());
        fprintf(stderr, "stack trace: %s
", ex.stackTrace());
        abort();
    }
    catch (const std::exception& ex)
    {
        fprintf(stderr, "reason: %s
", ex.what());
        abort();
    }
    catch (...)
    {
        fprintf(stderr, "unknown exception caught 
");
    throw; // rethrow
    }