Propagating Nested Exceptions Across Threads

Yes, you can propagate nested exceptions across threads, with some caveats.

In C++11 and later, if a function called by std::thread exits with an uncaught exception, the runtime captures that exception and stores it. When you call join() or get() on the std::thread or std::future object, it will rethrow that stored exception.

This works with nested exceptions too. If the thread function exits with an uncaught nested exception, it will be captured and rethrown when join() or get() is called.

For example:

1#include <exception>
2#include <iostream>
3#include <thread>
4
5void thread_func() {
6  try {
7    throw std::runtime_error{"Inner Exception"};
8  } catch (...) {
9    std::throw_with_nested(
10      std::logic_error{"Outer Exception"});
11  }
12}
13
14void join_thread() {
15  try {
16    std::thread t{thread_func};
17    t.join();
18  } catch (const std::exception& e) {
19    std::cout << "Caught exception: " << e.what() << '\n';
20    // Rethrow the std::runtime_error if desired
21    // std::rethrow_if_nested(e);
22  }
23}

However, there are some limitations:

1. The exception types must be copyable, because the exception is copied into the std::thread or std::future object.
2. If the thread function exits via other means (e.g., by calling std::terminate), the behavior is undefined.
3. If the std::thread or std::future object is destroyed without calling join() or get(), the stored exception is lost and std::terminate is called.

So while you can propagate nested exceptions across threads, it's important to handle and rethrow them properly to avoid unexpected behavior.