Using std::exception_ptr Across DLL Boundaries

Yes, std::exception_ptr can be used to transfer exceptions across DLL (dynamic-link library) boundaries, but there are some important considerations.

When an exception is thrown in a DLL and caught in the main executable (or vice versa), the exception object must be properly destructed. If the DLL and the executable use different C++ runtimes (which is common), this can lead to runtime errors or even crashes, because the exception object is not destructed properly.

std::exception_ptr helps mitigate this issue by providing a way to store and transfer the exception without depending on the specific exception object. The DLL can catch the exception, store it in a std::exception_ptr, and then transfer this std::exception_ptr to the executable. The executable can then rethrow the exception using std::rethrow_exception().

Here's a simplified example:

1// In the DLL
2#include <exception>
3#include <stdexcept>
4
5extern "C" __declspec(dllexport)
6std::exception_ptr captureException() {
7  try {
8    throw std::runtime_error("Exception from DLL");
9  } catch (...) {
10    return std::current_exception();
11  }
12}
13
14// In the executable
15#include <exception>
16#include <iostream>
17#include <stdexcept>
18
19// function from DLL
20std::exception_ptr captureException();
21
22int main() {
23  std::exception_ptr eptr = captureException();
24  try {
25    if (eptr) {
26      std::rethrow_exception(eptr);
27    }
28  } catch (const std::exception& e) {
29    std::cout << "Caught exception from DLL: "
30      << e.what() << "\n";
31  }
32}

1Caught exception from DLL: Exception from DLL

In this example, the exception is thrown and captured into a std::exception_ptr inside the DLL. This std::exception_ptr is then returned to the executable, where it's rethrown and caught.

However, it's important to note that while std::exception_ptr allows transferring exceptions across DLL boundaries, it doesn't completely solve all potential issues. For example, if the exception object contains data that is allocated in the DLL, there can still be issues with properly freeing that memory.

Therefore, when using exceptions across DLL boundaries, it's often best to define and use simple, lightweight exception classes that don't allocate resources or contain complex data structures.