Storing and Rethrowing Exceptions

A common scenario in exception handling is the need to store and transfer exceptions to other functions, and potentially rethrow those exceptions.

In this lesson, we delve into the nuances of rethrowing exceptions. We'll explore various scenarios, including conditional rethrowing, preventing data loss during rethrowing, and advanced techniques using std::exception_ptr.

Rethrowing Exceptions

To rethrow an exception, we just use the throw statement within our catch statement:

1try {
2 //...
3} catch(...) {
4  throw;
5}

One use case of rethrowing exceptions allows functions to "observe" exceptions flowing through them, without necessarily handling them. Below, our Login() function checks for AuthenticationError exceptions and generates some logging when they happen.

But even though Login() catches the exceptions, it doesn't handle them. It just rethrows it to be handled elsewhere in the stack. In this example, it is the main function that ultimately handles the exception:

1#include <iostream>
2using std::string;
3
Unchanged Code|Show
4class AuthenticationError{/*...*/}
19
20void Auth(string Email, string Password) {
21  throw AuthenticationError{Email, Password};
22}
23
24void Login(string Email, string Password) {
25  try {
26    Auth(Email, Password);
27  } catch (AuthenticationError& e) {
28    std::cout << "Security Alert - Login Fail: "
29      << e.Email << '\n';
30    throw;
31  }
32}
33
34int main() {
35  try {
36    Login("test@example.com", "wrong");
37  } catch (std::exception& e) {
38    std::cout << "Handled by main()";
39  }
40}

1Security Alert - Login Fail: test@example.com
2Handled by main()

Conditionally Rethrowing

The second main way we can use this is to conditionally rethrow. This allows us to write a catch block that is capable of handling some errors, whilst the rest are sent up the stack.

Below, our Login() function catches AuthenticationError exceptions again. This time, if the Password field is empty, the Login() function takes care of that locally. Otherwise, it rethrows it for main to handle:

1#include <iostream>
2using std::string;
3
Unchanged Code|Show
4class AuthenticationError{/*...*/}
19
20void Auth(string Email, string Password) {
21  throw AuthenticationError{Email, Password};
22}
23
24void Login(string Email, string Password) {
25  try {
26    Auth(Email, Password);
27  } catch (AuthenticationError& e) {
28    if (Password.empty()) {
29      std::cout << "Handled by Login()";
30    } else {
31      throw;
32    }
33  }
34}
35
36int main() {
37  try {
38    Login("test@example.com", "");
39  } catch (std::exception& e) {
40    std::cout << "Handled by main()";
41  }
42}

1Handled by Login()

Preventing Slicing (Data Loss) when Rethrowing

There is a common mistake when rethrowing exceptions. Rather than simply using the expression throw in isolation, we may be tempted to use it with the original error:

1#include <iostream>
2
3void func() {
4  try {
5    throw std::invalid_argument {
6      "Useful Error Message"
7    };
8  } catch (std::exception& e) {
9    std::cout << "First Catch: "
10              << e.what();
11    throw e;
12  }
13}
14
15int main() {
16  try {
17    func();
18  } catch (std::exception& e) {
19    std::cout << "\nSecond Catch: "
20              << e.what();
21  }
22}

1First Catch: Useful Error Message
2Second Catch: std::exception

Note the first catch statement has access to our custom message but, after rethrowing it, that information is lost.

This is because throw e; throws a copy of the exception, which is not desirable. Creating a copy unnecessarily has a performance impact, but worse, it can change the type, and that's what is happening in the previous program.

This is yet another example of where we can accidentally slice our objects by copying them to a base type.

In this case, we're copying a std::invalid_argument to a simpler std::exception object. In most compilers, the std::exception type doesn't store a custom error message, so it is lost in the process.

Unless we explicitly want to change the type of error that is thrown, we should simply use throw; in isolation:

1#include <iostream>
2
3void func() {
4  try {
5    throw std::invalid_argument {
6      "Useful Error Message"
7    };
8  } catch (std::exception& e) {
9    std::cout << "First Catch: "
10              << e.what();
11    throw;
12  }
13}
14
15int main() {
16  try {
17    func();
18  } catch (std::exception& e) {
19    std::cout << "\nSecond Catch: "
20              << e.what();
21  }
22}

1First Catch: Useful Error Message
2Second Catch: Useful Error Message

We can also rethrow exceptions using more advanced techniques involving std::rethrow_exception(), which we cover later:

Understanding std::exception_ptr

There are scenarios where we might want to capture an exception, pass it to other functions, and potentially rethrow it later. In this regard, there is nothing special about objects that are thrown as part of exceptions. They're regular objects, and can be stored and transferred as normal:

1#include <iostream>
2#include <stdexcept>
3
4void HandleException(std::runtime_error& e) {
5  std::cout << "Handled std::runtime_error";
6}
7
8int main() {
9  try {
10    throw std::logic_error{"Error"};
11  } catch (std::runtime_error& e) {
12    HandleException(e);
13  }
14}

1Handled std::runtime_error

However, this technique naturally requires us to know the specific type of exception we're working with. That is not always viable, and this is where std::exception_ptr type comes into play.

The std::exception_ptr is a standard type that can hold a pointer to any type of object that was thrown. It's essentially used as a vehicle to store and transfer exceptions between different parts of a program. It can be thought of as a safe way to handle exceptions outside of the usual try-catch blocks.

The std::excepion_ptr type can be null - that is, not pointing at any exception. We can check if it is null by coercing it to a boolean, in the usual way.

1void HandleException(std::exception_ptr e) {
2  if (e) {
3    std::cout << "We have an exception";
4  } else {
5    std::cout << "There is no exception";
6  }
7}

Capturing Exceptions with std::current_exception()

To capture an exception in a std::exception_ptr, we use the std::current_exception() function.

• This function is called within a catch block.
• It captures the currently handled exception and returns a std::exception_ptr that holds it.
• If no exception is being handled, it returns a null std::exception_ptr.

1#include <stdexcept>
2#include <iostream>
3
4void HandleException(std::exception_ptr e) {
5  if (e) {
6    std::cout << "We have an exception\n";
7  } else {
8    std::cout << "There is no exception\n";
9  }
10}
11
12int main() {
13  try {
14    throw std::runtime_error{"Error"};
15  } catch(...) {
16    HandleException(std::current_exception());
17  }
18
19  // std::current_exception() returns null here
20  HandleException(std::current_exception());
21}

1We have an exception
2There is no exception

Rethrowing with std::rethrow_exception()

Once an exception is captured into a std::exception_ptr, it can be rethrown later using std::rethrow_exception():

• This function takes a std::exception_ptr as its argument.
• When called, it rethrows the exception that was previously captured.
• We should ensure that the std::exception_ptr is not null before calling std::rethrow_exception().

Below, our HandleException function rethrows its std::exception_ptr parameter and immediately handles it. Because we included a default handler using catch(...), this HandleException function can handle any type of exception:

1#include <iostream>
2#include <stdexcept>
3
4class SomeCustomError {};
5
6void HandleException(std::exception_ptr e) {
7  if (e) {
8    try {
9      std::rethrow_exception(e);
10    } catch (std::runtime_error& e) {
11      std::cout << "Handled std::runtime_error";
12    } catch (SomeCustomError& e) {
13      std::cout << "Handled SomeCustomError";
14    } catch (...) {
15      std::cout << "Handled everything else";
16    }
17  }
18}
19
20int main() {
21  try {
22    throw std::runtime_error{"Error"};
23  } catch (...) {
24    HandleException(std::current_exception());
25  }
26}

1Handled std::runtime_error

As usual, not every exception needs to be handled immediately. We can let exceptions escape to be handled elsewhere in the stack.

In the previous example, updating our catch(...) block to simply rethrow the exception would mean HandleException() takes care of std::runtime_error and SomeCustomError only, with everything else being sent back up the stack:

1#include <iostream>
2#include <stdexcept>
3
4class SomeCustomError {};
5
6void HandleException(std::exception_ptr e) {
7  if (e) {
8    try {
9      std::rethrow_exception(e);
10    } catch (std::runtime_error& e) {
11      std::cout << "Handled std::runtime_error";
12    } catch (SomeCustomError& e) {
13      std::cout << "Handled SomeCustomError";
14    } catch (...) {
15      std::rethrow_exception(e);
16    }
17  }
18}
19
20int main() {
21  try {
22    throw std::logic_error{"Error"};
23  } catch (...) {
24    try {
25      HandleException(std::current_exception());
26    } catch (...) {
27      std::cout << "HandleException() couldn't"
28        " handle that, so main caught it";
29    }
30  }
31}

1HandleException() couldn't handle that, so main caught it

Practical Use Cases

The combination of std::exception_ptr, std::current_exception(), and std::rethrow_exception() is particularly useful in scenarios like:

• Deferred exception handling, where an exception needs to be transported to a different context for handling.
• Complex systems where exceptions need to be passed across different layers or threads.
• When an exception must be stored temporarily for logging or auditing purposes before being rehandled or propagated.

Summary

This lesson has covered techniques to store and rethrow exceptions using advanced techniques. The key topics we learned included:

• Rethrowing exceptions correctly using throw; to avoid data loss and object slicing.
• Practical uses, including conditional rethrowing to handle specific error conditions while passing others up the call stack.
• Utilizing std::exception_ptr for flexible handling and transfer of exceptions across different parts of a program.
• Understanding and using std::current_exception() to capture exceptions and std::rethrow_exception() to rethrow them as needed.

Free and Unlimited Access

Professional C++

Unlock the true power of C++ by mastering complex features, optimizing performance, and learning expert workflows used in professional development

View Course