Example
C++
#include <iostream>
#include <stdexcept>
void function1() {
try {
// Some code that may throw an exception
throw std::runtime_error("Exception from function1");
}
catch (const std::exception& e) {
std::cout << "Caught exception in function1: " << e.what() << std::endl;
// Rethrow the exception
throw;
}
}
void function2() {
try {
function1();
}
catch (const std::exception& e) {
std::cout << "Caught exception in function2: " << e.what() << std::endl;
// Handle the exception or rethrow it
throw;
}
}
int main() {
try {
function2();
}
catch (const std::exception& e) {
std::cout << "Caught exception in main: " << e.what() << std::endl;
}
return 0;
}
You can also try this code with Online C++ Compiler
In this example, we have three functions: `function1`, `function2`, and `main`. Let's go through the flow of the program:
1. Inside `function1`, an exception of type `std::runtime_error` is thrown with the message "Exception from function1".
2. The exception is caught by the catch block in `function1`. It prints a message indicating that the exception was caught and then rethrows the exception using the `throw` statement.
3. The rethrown exception propagates up to `function2`, where it is caught by the catch block. It prints a message indicating that the exception was caught in `function2` and then rethrows the exception again.
4. The rethrown exception from `function2` propagates up to the `main` function, where it is caught by the catch block. It prints a message indicating that the exception was caught in `main`.
The output of this program will be:
Caught exception in function1: Exception from function1
Caught exception in function2: Exception from function1
Caught exception in main: Exception from function1
You can see clearly, the exception thrown in `function1` is caught and rethrown multiple times until it reaches the `main` function, where it is finally handled.
Advantages of Rethrowing Exceptions
1. Separation of Concerns: Rethrowing exceptions allows you to separate the error handling logic from the main logic of your program. You can catch an exception at a lower level, perform some specific actions, and then rethrow the exception to be handled by a higher-level catch block. This promotes a cleaner and more modular code structure.
2. Centralized Error Handling: By rethrowing exceptions, you can propagate the exception to a centralized error handling mechanism. This allows you to handle exceptions at a higher level in your program, such as in the main function or a dedicated error handling module. Centralized error handling makes it easier to manage and maintain the error handling logic in one place.
3. Preserving Exception Information: When you rethrow an exception, it preserves the original exception type and information. This means that the higher-level catch block can access the original exception object and retrieve relevant details such as the error message, stack trace, or custom exception data. Preserving the exception information helps in debugging and provides valuable context for error reporting.
4. Flexibility and Control: Rethrowing exceptions gives you flexibility and control over the exception handling process. You can choose to handle an exception partially at a lower level, perform necessary cleanup or logging, and then rethrow it for further handling. This allows you to implement a multi-layered exception handling strategy where each layer can handle specific aspects of the exception.
5. Propagating Exceptions Across Boundaries: Rethrowing exceptions is particularly useful when propagating exceptions across module or component boundaries. If an exception occurs in a low-level component, you can catch it, perform any necessary actions specific to that component, and then rethrow the exception to be caught and handled by the higher-level component or the caller.
Frequently Asked Questions
Can you rethrow a different exception than the one you caught?
No, when you rethrow an exception using the throw statement without any argument, it rethrows the original exception that was caught. You cannot change the exception type or throw a different exception during rethrowing.
Is it necessary to catch an exception before rethrowing it?
Yes, you need to catch an exception using a catch block before you can rethrow it. Rethrowing an exception is only possible from within a catch block.
Can you modify the exception object before rethrowing it?
No, when you rethrow an exception, it preserves the original exception object. You cannot modify the exception object before rethrowing it. However, you can log additional information or perform other actions before rethrowing.
Conclusion
In this article, we talked about the concept of rethrowing exceptions in C++. We learned that rethrowing an exception allows you to catch an exception, perform some actions, and then propagate the same exception to be handled by an outer catch block. Rethrowing exceptions has many advantages like separation of concerns, centralized error handling, preserving exception information, flexibility, and the ability to propagate exceptions across boundaries.
You can also check out our other blogs on Code360.
39+ registered 
