Rethrowing Exceptions

Rethrowing an exception in C++ refers to the process of catching an exception and then throwing it again without modifying it. This is useful when you want to perform some action or logging before propagating the exception to the next level of exception handling.

To rethrow an exception, you simply use the throw keyword without any argument inside a catch block. Here's an example:

1#include <iostream>
2
3void foo() {
4  try {
5    // Some code that may throw an exception
6    throw std::runtime_error("Something went wrong");
7  } catch (const std::exception& ex) {
8    std::cout << "Caught exception in foo: "
9      << ex.what() << std::endl;
10    throw;  // Rethrow the exception
11  }
12}
13
14int main() {
15  try {
16    foo();
17  } catch (const std::exception& ex) {
18    std::cout << "Caught exception in main: "
19      << ex.what() << std::endl;
20  }
21}

1Caught exception in foo: Something went wrong
2Caught exception in main: Something went wrong

In this example, the foo function catches an exception of type std::exception, logs a message, and then rethrows the exception using the throw keyword without any argument. The exception is then caught in the main function, where it is handled and another message is logged.

Rethrowing exceptions can be useful in the following scenarios:

Logging and error reporting

• When an exception is caught, you may want to log some information about the exception or perform some error reporting before propagating the exception further.
• Rethrowing the exception allows you to handle the exception at multiple levels while still preserving the original exception information.

Modifying exception information

• Sometimes, you may want to catch an exception, modify some information or add additional context, and then rethrow the exception with the updated information.
• This can be done by catching the exception, modifying it, and then rethrowing it.

Handling exceptions at different levels

• Rethrowing exceptions allows you to handle exceptions at different levels of the call stack.
• You can catch an exception at a lower level, perform some actions, and then rethrow it to be handled by higher-level code.

Here's an example that demonstrates modifying exception information before rethrowing:

1#include <iostream>
2#include <stdexcept>
3
4class CustomException
5  : public std::runtime_error {
6 public:
7  CustomException(
8    const std::string& message, int errorCode)
9      : std::runtime_error(message),
10        errorCode_(errorCode) {}
11
12  int getErrorCode() const {
13    return errorCode_;
14  }
15
16 private:
17  int errorCode_;
18};
19
20void processData(int data) {
21  try {
22    if (data < 0) {
23      throw CustomException("Invalid data", -1);
24    }
25    // Process the data
26  } catch (const CustomException& ex) {
27    std::cout << "Caught CustomException in "
28      "processData: " << ex.what() << std::endl;
29
30    throw CustomException(
31      ex.what(), ex.getErrorCode() + 100);
32  }
33}
34
35int main() {
36  try {
37    processData(-5);
38  } catch (const CustomException& ex) {
39    std::cout
40      << "Caught CustomException in main: "
41      << ex.what()
42      << ", Error Code: " << ex.getErrorCode();
43  }
44}

1Caught CustomException in processData: Invalid data
2Caught CustomException in main: Invalid data, Error Code: 99

In this example, we define a custom exception class CustomException that inherits from std::runtime_error and adds an error code. Inside the processData function, if an exception of type CustomException is caught, we log a message and then rethrow the exception with an updated error code.

When the exception is caught in the main function, it includes the modified error code, providing additional context about the exception.

Rethrowing exceptions allows you to handle and modify exceptions at different levels of the call stack while preserving the original exception information. However, it's important to use rethrowing judiciously and ensure that the exception is eventually handled and not propagated indefinitely.