To store an exception, the type std::exception_ptr is used. std::exception_ptr is a smart pointer type with shared ownership semantics, not unlike std::shared_ptr (see Chapter 3, Memory Management and Exception Safety). An instance of std::exception_ptr is copyable and movable and can be passed to other functions potentially across threads. A default-constructed std::exception_ptr is a null object that does not point to any exception. Copying a std::exception_ptr object creates two instances that manage the same underlying exception object. The underlying exception object continues to exist as long as the last exception_ptr instance containing it exists.

The function std::current_exception, when called inside a catch-block, returns the active exception for which the catch-block was executed, wrapped in an instance of std::exception_ptr. When called outside a catch-block, it returns a null std::exception_ptr instance.

The function std::rethrow_exception is passed an instance of std::exception_ptr (which must not be null) and throws the exception contained in the std::exception_ptr instance.

Listing A.3: Using std::exception_ptr

 1 #include <stdexcept>
 2 #include <iostream>
 3 #include <string>
 4 #include <vector>
 5
 6 void do_work()
 7 {
 8   throw std::runtime_error("Exception in do_work");
 9 }
10
11 std::vector<std::exception_ptr> exceptions;
12
13 void do_more_work()
14 {
15   std::exception_ptr eptr;
16
17   try {
18     do_work();
19   } catch (...) {
20     eptr = std::current_exception();
21   }
22
23   std::exception_ptr eptr2(eptr);
24   exceptions.push_back(eptr);
25   exceptions.push_back(eptr2);
26 }
27
28 int main()
29 {
30   do_more_work();
31
32   for (auto& eptr: exceptions) try {
33     std::rethrow_exception(eptr);
34   } catch (std::exception& e) {
35     std::cout << e.what() << '\n';
36   }
37 }

Running the preceding example prints the following:

Exception in do_work
Exception in do_work

The main function calls do_more_work (line 30), which in turn calls do_work (line 18), which simply throws a runtime_error exception (line 8) that finds its way down to a catch-block in do_more_work (line 19). We declare an object eptr of type std::exception_ptr in do_more_work (line 15) and inside the catch-block, we call std::current_exception and assign the result to eptr. Later, we create a copy of eptr (line 23), and push both instances into a global vector of exception_ptrs (lines 24-25).

In the main function, we run through the exception_ptr instances in the global vector, throw each using std::rethrow_exception (line 33), catch it and print its message. Note that in the process, we print the message from the same exception twice because we have two instances of exception_ptr containing the same exception.

In pre-C++11 environments, you can use the boost::exception_ptr type to store exceptions and boost::rethrow_exception to throw the exception stored in boost::exception_ptr. There is also the boost::current_exception function which works akin to std::current_exception. But without underlying language support, it requires help from the programmer to function.

In order for boost::current_exception to return the currently active exception wrapped in boost::exception_ptr, we must modify the exception before throwing it to make it amenable to be handled using this mechanism. To do this, we call boost::enable_current_exception on the exception to be thrown. The following snippet illustrates this:

Listing A.4: Using boost::exception_ptr

 1 #include <boost/exception_ptr.hpp>
 2 #include <iostream>
 3
 4 void do_work()
 5 {
 6   throw boost::enable_current_exception(
 7             std::runtime_error("Exception in do_work"));
 8 }
 9
10 void do_more_work()
11 {
12   boost::exception_ptr eptr;
13 
14   try {
15     do_work();
16   } catch (...) {
17     eptr = boost::current_exception();
18   }
19
20   boost::rethrow_exception(eptr);
21 }
22
23 int main() {
24   try {
25     do_more_work();
26   } catch (std::exception& e) {
27     std::cout << e.what() << '\n';
28   }
29 }