Throwing Nested Exceptions from Destructors

No, it's not safe to throw any exceptions, including nested exceptions, from a destructor.

In C++, destructors are called in many situations, including during stack unwinding when an exception is thrown. If a destructor itself throws an exception during this process, it leads to undefined behavior, typically resulting in immediate termination of the program.

Here's an example of what not to do:

1#include <stdexcept>
2
3class Dangerous {
4public:
5  ~Dangerous() {
6    try {
7      throw std::runtime_error{
8        "Inner Exception"};
9    } catch(...) {
10      std::throw_with_nested(std::logic_error{
11        "Outer Exception"});
12    }
13  }
14};
15
16int main() {
17  try {
18    Dangerous d;
19    throw std::exception{};
20  } catch(const std::exception&) {
21  }
22}

In this code, when the std::exception is thrown in main(), the Dangerous object d will be destroyed as part of stack unwinding. But its destructor throws another exception, leading to undefined behavior.

To avoid this, the C++ standard specifies that destructors should not throw exceptions. If a destructor needs to handle an exception, it should catch and handle it internally, not let it propagate.

For example:

1#include <stdexcept>
2#include <iostream>
3
4class SaferButNotIdeal {
5 public:
6  ~SaferButNotIdeal() noexcept {
7    try {
8      // Some operation that might throw
9      throw std::exception{};
10    } catch (...) {
11      // Handle the exception, but don't rethrow
12      std::cout << "Caught exception in "  
13                   "destructor\n";         
14    }
15  }
16};
17
18int main() {
19  SaferButNotIdeal s;
20}

1Caught exception in destructor

Even better is to design your classes so that their destructors don't throw in the first place, by ensuring all operations in the destructor are non-throwing.