correct way to store an exception in a variable

Question

I have an API which internally has some exceptions for error reporting. The basic structure is that it has a root exception object which inherits from std::exception, then it will throw some subclass of that.

Since catching an exception thrown in one library or thread and catching it in another can lead to undefined behavior (at least Qt complains about it and disallows it in many contexts). I would like to wrap the library calls in functions which will return a status code, and if an exception occurred, a copy of the exception object.

What is the best way to store an exception (with it's polymorphic behavior) for later use? I believe that the c++0x future API makes use of something like this. So what is the best approach?

The best I can think of is to have a clone() method in each exception class which will return a pointer to an exception of the same type. But that's not very generic and doesn't deal with standard exceptions at all.

Any thoughts?

EDIT: It seems that c++0x will have a mechanism for this. It is described as "library magic". Does that mean that is doesn't require any of the language features of c++0x? if not, are there any implementations which are compatible with c++03?

EDIT: Looks like boost has an implementation of exception copying. I'll keep the question open for any non boost::copy_exception answers.

EDIT: To address j_random_hacker's concerns about the root cause of the exception being an out of memory error. For this particular library and set of exceptions, this is not the case. All exceptions derived from the root exception object represent different types of parsing errors caused by invalid user input. Memory related exceptions will simply cause a std::bad_alloc to be thrown which is addressed separately.

Answer 1

As of C++11, this can be done using std::exception_ptr.

(I use this in a class that makes an std::thread interruptible provided that the underlying thread implementation is a POSIX thread. To handle exceptions that may be thrown in the user's code - which causes problems if they are thrown in a certain critical section of my implementation - I store the exception using std::exception_ptr, then throw it later once the critical section has completed.)

To store the exception, you catch it and store it in the ptr variable.

std::exception_ptr eptr;
try {
    ... do whatever ...
} catch (...) {
    eptr = std::current_exception();
}

You can then pass eptr around wherever you like, even into other threads (according to the docs - I haven't tried that myself). When it is time to use (i.e. throw) it again, you would do the following:

if (eptr) {
    std::rethrow_exception(eptr);
}

If you want to examine the exception, you would simply catch it.

try {
    if (eptr) {
        std::rethrow_exception(eptr);
    }
} catch (const std::exception& e) {
    ... examine e ...
} catch (...) {
    ... handle any non-standard exceptions ...
}

Answer 2

You're allowed to throw anything, including pointers. You could always do something like this:

throw new MyException(args);

And then in the exception handler store the caught pointer, which will be fully polymorphic (below assuming that MyException derives from std::exception):

try {

   doSomething(); // Might throw MyException*

} catch (std::exception* pEx) {

   // store pEx pointer
}

You just have to be careful about memory leaks when you do it this way, which is why throw-by-value and catch-by-reference is normally used.

More about catch-by-pointer: http://www.parashift.com/c++-faq-lite/exceptions.html#faq-17.8