Throwing Exceptions

The throw keyword is used to signal a runtime error. When an exception is thrown, the C++ runtime initiates Stack Unwinding, destroying all local automatic variables in the current scope and outer scopes until a suitable catch block is found.

The Rethrowing Dilemma: throw; vs throw e;

Inside a catch block, developers sometimes need to log the error and pass it up. The method used to rethrow is crucial:

• throw;: Rethrows the original exception object. This preserves its dynamic type, allowing base catch blocks further up the stack to correctly capture the derived type.
• throw e;: Creates a new exception object of the static parameter type. This slices the exception, mutating the object to the base class and losing the original type information.

Code Walkthrough

This program demonstrates exception propagation, local object destruction, and correct rethrowing.

#include <iostream>
#include <stdexcept>
struct Resource {
    std::string name;
    Resource(std::string n) : name(n) { std::cout << name << " acquired\n"; }
    ~Resource() { std::cout << name << " destructed\n"; }
};
void intermediateFunction() {
    Resource res("LocalResource"); // Properly cleaned up during stack unwinding
    throw std::runtime_error("Error in intermediateFunction");
}
int main() {
    try {
        try {
            intermediateFunction();
        } catch (const std::exception& e) {
            std::cout << "Logging inside nested catch: " << e.what() << std::endl;
            throw; // Correct: Rethrows original std::runtime_error
        }
    } catch (const std::runtime_error& e) {
        std::cout << "Outer catch successfully caught: " << e.what() << std::endl;
    }
    return 0;
}

Interview-Relevant Information