Propagating Nested Exceptions Across DLL Boundaries

Propagating exceptions, including nested exceptions, across DLL (dynamically linked library) boundaries is possible but requires careful design.

The main challenge is that the DLL and the calling code might use different memory allocators. If an exception is allocated in the DLL using the DLL's allocator, but then caught and deallocated in the calling code using the calling code's allocator, it can lead to runtime errors or memory corruption.

To safely propagate exceptions across DLL boundaries:

1. The DLL and the calling code should use the same C++ runtime library, to ensure they use the same memory allocator.
2. The exception types should be defined in a header file that is shared between the DLL and the calling code, to ensure they have the same definition.
3. The exception types should have a non-throwing destructor, to avoid the issues with throwing destructors mentioned in the previous answer.
4. The DLL function should catch any internal exceptions and translate them into error codes or exceptions that are part of the DLL's public interface.

Here's an example:

1// DLL.cpp
2#include <stdexcept>
3#include "SharedTypes.h"
4
5// SharedTypes.h
6struct DLLException : std::exception {
7  const char* what() const noexcept override {
8    return "Exception from DLL"; }
9};
10
11extern "C" __declspec(dllexport)
12void DLLFunction() {
13  try {
14    // Some operation that might throw
15    throw std::runtime_error{"Internal error"};
16  } catch (...) {
17    std::throw_with_nested(DLLException{});  
18  }
19}

1// Main.cpp
2#include <iostream>
3#include "SharedTypes.h"
4
5int main() {
6  try {
7    DLLFunction();
8  } catch (const DLLException& e) {
9    std::cout << "Caught DLLException: "
10      << e.what() << '\n';
11    std::rethrow_if_nested(e);
12  } catch (const std::exception& e) {
13    std::cout << "Caught nested exception: "
14      << e.what() << '\n';
15  }
16}

In this design, the DLLFunction catches any internal exceptions and wraps them in a DLLException, which is defined in a shared header file. The main function can then catch DLLException and access any nested exceptions.

However, even with this design, there are still potential pitfalls. For maximum portability and safety, it's often better for DLL functions to return error codes instead of throwing exceptions.