Rethrow Expression

Documentation Index

Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt

Use this file to discover all available pages before exploring further.

throw;

• Dynamic Type Preservation: When an exception is caught by reference to a base class, throwing the named variable (e.g., throw e;) invokes the copy constructor of the base class, resulting in object slicing. A rethrow expression (throw;) bypasses this by propagating the exact original exception object, fully retaining its derived dynamic type.
• Object Identity: The expression does not allocate or initialize a new exception object. It extends the lifetime of the existing exception object in memory until the next handler in the call stack completes its execution.
• Execution Flow: Upon evaluation, control immediately exits the current catch block. The C++ runtime resumes stack unwinding to locate the next matching catch clause in the call chain.

• Valid Context: A rethrow expression is valid only when an exception is currently active. While typically found lexically nested within a catch block, it is also valid if evaluated dynamically inside a function invoked directly or indirectly from within a catch block.
• Invalid Context: If a rethrow expression is evaluated when no exception is currently being handled (i.e., outside the dynamic scope of an active exception handler), the C++ runtime immediately invokes std::terminate(), which aborts the program.

try {
    // ...
} catch (BaseException& e) {
    throw e; // INCORRECT: Copies 'e' as a BaseException, slicing any derived data.
}

try {
    // ...
} catch (BaseException& e) {
    throw;   // CORRECT: Rethrows the original object, preserving its derived type.
}