Capturing and Rethrowing Custom Exceptions

Yes, std::exception_ptr can be used to capture and rethrow any type of exception, including custom exception types.

Here's an example that demonstrates this:

1#include <exception>
2#include <iostream>
3#include <string>
4
5class CustomException : public std::exception {
6public:
7  explicit CustomException(
8    const std::string& what) : m_what(what) {}
9  const char* what() const noexcept override {
10    return m_what.c_str();
11  }
12private:
13  std::string m_what;
14};
15
16void throwCustomException() {
17  throw CustomException(
18    "This is a custom exception");
19}
20
21std::exception_ptr captureException() {
22  try {
23    throwCustomException();
24  } catch (...) {
25    return std::current_exception();
26  }
27  return nullptr;
28}
29
30void rethrowException(std::exception_ptr eptr) {
31  try {
32    if (eptr) {
33      std::rethrow_exception(eptr);
34    }
35  } catch (const CustomException& e) {
36    std::cout << "Caught CustomException: "
37      << e.what() << "\n";
38  } catch (const std::exception& e) {
39    std::cout << "Caught std::exception: "
40      << e.what() << "\n";
41  }
42}
43
44int main() {
45  std::exception_ptr eptr = captureException();
46  rethrowException(eptr);
47}

1Caught CustomException: This is a custom exception

In this example:

1. We define a custom exception class CustomException that derives from std::exception.
2. The function throwCustomException() throws a CustomException.
3. The function captureException() calls throwCustomException(), catches the exception, and captures it into a std::exception_ptr using std::current_exception().
4. The main() function calls captureException() to get the std::exception_ptr, and then passes it to rethrowException().
5. rethrowException() rethrows the exception using std::rethrow_exception(). It then catches the rethrown exception, first trying to catch CustomException, and then std::exception.

This demonstrates that std::exception_ptr can indeed capture and rethrow custom exception types. The custom exception can be caught and handled as expected when it's rethrown.

This capability is particularly useful when you need to transport exceptions through interfaces that don't know about your custom exception types, such as between layers of a complex system or across DLL boundaries.