Nested Exceptions

Whilst handling an exception within a catch block, there may be scenarios where yet another exception can occur, thus leaving us with two exceptions being active at the same time.

To handle this, we have the concept of a nested exception. This allows us to throw a new exception, and for that exception to include a reference to the original. So, the original exception is said to be nested within the new exception.

Creating Nested Exceptions

To do this, we use the std::throw_with_nested() function, passing in our new exception:

1// Auth.h
2#pragma once
3#include <string>
4
Unchanged Code|Show
5class AuthenticationError{/*...*/}
20
21class SecurityError : public std::exception {};
22
23void Auth(
24  std::string Email, std::string Password) {
25  throw AuthenticationError{Email, Password};
26}
27
28void Login(
29  std::string Email, std::string Password) {
30  try {
31    Auth(Email, Password);
32  } catch (AuthenticationError& e) {
33    std::throw_with_nested(SecurityError{});  
34  }
35}

Above, our Login() function will emit a SecurityError, with an AuthenticationError nested within it. We can catch the SecurityError in the normal way:

1#include <iostream>
2#include "Auth.h"
3
4int main() {
5  try {
6    Login("test@example.com", "secret");
7  } catch (SecurityError& e) {
8    std::cout << "Caught a SecurityError";
9  }
10  std::cout << "\nProgram recovered";
11}

When we handle the exception in this way, we also handle any nested exceptions that it might have contained. As a result, our program fully recovers:

1Caught a SecurityError
2Program recovered

Typically, however, this is not what we want. If we’re using nested exceptions in our project, we need to consider the possibility that the exceptions we receive might contain nested exceptions that also need to be handled. We cover techniques on how to do this in the next few sections.

Accessing Nested Exceptions

The throw_with_nested() function implements nested exceptions using multiple inheritance, meaning a class can inherit from multiple base classes. This is a technique we’ll cover in detail later in the course.

For now, we can think of the object created by throw_with_nested() as having two types. One of the types is std::nested_exception, and the other is the type of object we provided as an argument. In the previous example, that was our user-defined type SecurityError:

1std::throw_with_nested(SecurityError{});

To check if our type is a std::nested_exception, we can dynamic_cast it in the usual way:

1#include <iostream>
2#include "Auth.h"
3
4int main() {
5  try {
6    Login("test@example.com", "secret");
7  } catch (SecurityError& e) {
8    std::cout << "Caught a SecurityError";
9
10    auto NestedException{
11      dynamic_cast<std::nested_exception*>(&e)};
12    if (NestedException) {
13      std::cout <<
14        "\nThere's a nested exception in here";
15    }
16  }
17  std::cout << "\nProgram recovered";
18}

1Caught a SecurityError
2There's a nested exception in here
3Program recovered

However, the easiest way to detect and deal with nested exceptions tends to be to rethrow them.

Rethrowing Nested Exceptions

Once we’ve dealt with the outer exception, we can decide to rethrow the nested exception, if there is one.

The easiest way to do this is through the std::rethrow_if_nested() function:

1#include <iostream>
2#include "Auth.h"
3
4int main() {
5  try {
6    Login("test@example.com", "secret");
7  } catch (SecurityError& e) {
8    std::cout << "Caught a SecurityError";
9
10    try {
11      std::rethrow_if_nested(e);
12    } catch (...) {
13      std::cout << "\nThere's a nested "
14        "exception in here";
15    }
16  }
17  std::cout << "\nProgram recovered";
18}

1Caught a SecurityError
2There's a nested exception in here
3Program recovered

As we might expect, we can handle a nested exception like any other. Our catch block can specify the exception type it is capable of handling:

1#include <iostream>
2#include "Auth.h"
3
4int main() {
5  try {
6    Login("test@example.com", "secret");
7  } catch (SecurityError& e) {
8    std::cout << "Caught a SecurityError";
9
10    try {
11      std::rethrow_if_nested(e);
12    } catch (AuthenticationError& e) {
13      std::cout
14        << "\nNested AuthenticationError: "
15        << e.Email;
16    }
17  }
18  std::cout << "\nProgram recovered";
19}

1Caught a SecurityError
2Nested AuthenticationError: test@example.com
3Program recovered

Also, we don’t need to handle nested exceptions locally. We can just throw them and let a function elsewhere on the call stack deal with it:

1void SomeFunction() {
2  try {
3    Login("test@example.com", "secret");
4  } catch (SecurityError& e) {
5    std::cout << "Caught a SecurityError";
6    std::rethrow_if_nested(e);
7  }
8}

Handling Nested Exceptions Recursively

Exceptions can be nested arbitrarily deeply. For example, in a complex project that uses nested exceptions, we can have an exception, nested within an exception, nested within another exception.

The contrived GenerateExceptions() function simulates this scenario:

1#include <iostream>
2
3void GenerateExceptions() {
4  try {
5    throw std::runtime_error{"Error One"};
6  } catch (...) {
7    try {
8      std::throw_with_nested(
9        std::runtime_error{"Error Two"});
10    } catch (...) {
11      std::throw_with_nested(
12        std::runtime_error{"Error Three"});
13    }
14  }
15}

When we catch an exception, we’ll often want to unwind all of the exceptions contained within it. In the following example, the HandleExceptions() function demonstrates how we can do this:

1#include <iostream>
2
Unchanged Code|Show
3void GenerateExceptions() {/*...*/}
17
18void HandleExceptions(const std::exception& e) {
19  std::cout << "\nHandling " << e.what();
20  try {
21    std::rethrow_if_nested(e);
22  } catch (const std::exception& Nested) {
23    HandleExceptions(Nested); // Recursion
24  }
25}
26
27int main() {
28  try {
29    GenerateExceptions();
30  } catch (std::exception& e) {
31    HandleExceptions(e);
32  }
33}

1Handling Error Three
2Handling Error Two
3Handling Error One

This is an example of a recursive function. A recursive function conditionally calls itself.

In this case, HandleException() calls itself if std::rethrow_if_nested(e); throws an exception. In other words, it calls itself if the exception it received as a parameter contains a nested exception.

This works because each call to HandleExceptions() catches and handles the current nested exception, then calls itself again with the next nested exception. This process repeats, unwinding the nested exceptions from the inside out, until std::rethrow_if_nested(e) doesn't throw anymore, indicating there are no more nested exceptions.

Recursion is a relatively unintuitive concept, so don’t worry if this examples doesn’t make sense. We cover recursion starting with simpler examples in a dedicated lesson later in the course.

Summary

This lesson provided an exploration of nested exceptions, demonstrating their implementation, handling, and practical applications. The key topics we learned included:

• Understanding of nested exceptions and their usage with std::throw_with_nested() for handling multiple layers of exceptions.
• Familiarity with accessing and identifying nested exceptions using dynamic_cast and std::nested_exception.
• Knowledge of rethrowing nested exceptions using std::rethrow_if_nested() and handling them appropriately.
• Insight into recursively handling deeply nested exceptions, showcasing how to systematically unravel and address each layer of errors.

Next Lesson

Function Try Blocks

Learn about Function Try Blocks, and their importance in managing exceptions in constructors

ContinueView Course