What is a good strategy for handling exceptions that are thrown while already handling another exception?

Question

Ryan McCombe · Accepted Answer

When an exception is thrown while already handling another exception, it's called a nested exception. This can lead to tricky situations and potential resource leaks if not handled carefully.

One strategy is to catch and handle the nested exception separately, and then continue handling the original exception:

1#include <iostream>
2#include <stdexcept>
3
4void handleException() {
5  try {
6    throw std::runtime_error(
7      "Original exception");
8  } catch (const std::exception& e) {
9    std::cout << "Handling: "
10      << e.what() << "\n";
11    try {
12      throw std::logic_error("Nested exception");
13    } catch (const std::exception& nested_e) {
14      std::cout << "Handling nested: "
15        << nested_e.what() << "\n";
16    }
17    std::cout << "Continuing handling "
18      "original exception\n";
19  }
20}
21
22int main() {
23  handleException();
24}

1Handling: Original exception
2Handling nested: Nested exception
3Continuing handling original exception

Another approach is to capture the nested exception using std::current_exception(), store it in a std::exception_ptr, and then rethrow it after finishing handling the original exception:

1#include <exception>
2#include <iostream>
3#include <stdexcept>
4
5void handleException() {
6  std::exception_ptr nested_eptr;
7  try {
8    throw std::runtime_error(
9      "Original exception");
10  } catch (const std::exception& e) {
11    std::cout << "Handling: " << e.what() << "\n";
12    try {
13      throw std::logic_error("Nested exception");
14    } catch (...) {
15      nested_eptr = std::current_exception();
16    }
17    std::cout << "Continuing handling "
18      "original exception\n";
19  }
20  if (nested_eptr) {
21    std::rethrow_exception(nested_eptr);
22  }
23}
24
25int main() {
26  try {
27    handleException();
28  } catch (const std::exception& e) {
29    std::cout << "Caught rethrown nested "
30      "exception: " << e.what() << "\n";
31  }
32}

1Handling: Original exception
2Continuing handling original exception
3Caught rethrown nested exception: Nested exception

This ensures the nested exception isn't lost and can be handled at a higher level if needed.

Storing and Rethrowing Exceptions

Handling Nested Exceptions

Storing and Rethrowing Exceptions

Professional C++

Questions & Answers