Function Try Block

A function-try-block is an alternative syntax for a function definition where the entire function body, and optionally the constructor member initializer list, is encapsulated within a try block. It provides a mechanism to intercept exceptions thrown during the initialization of base classes and class members, which a standard try-catch block nested inside the function body cannot capture.

Syntax

The try keyword is placed before the member initializer list in constructors, or before the compound statement (the opening brace {) in regular functions. The catch clauses immediately follow the closing brace of the function body.

Constructor Syntax:

ClassName::ClassName(int param)
try : BaseClass(param), memberVariable(param) {
    // Constructor body
}
catch (const std::exception& e) {
    // Handler block
}

Regular Function Syntax:

ReturnType functionName(int param)
try {
    // Function body
}
catch (const std::exception& e) {
    // Handler block
}

Execution Mechanics and Rules

1. Scope and Visibility

• Parameters: Function parameters are in scope and accessible within the catch block.
• Local Variables: Variables declared inside the function body (the compound statement following try) are out of scope and inaccessible within the catch block.
• Class Members: In a constructor function-try-block, if an exception is thrown by a base class initializer, a member initializer, or within the constructor body itself, all fully constructed base classes and members are destroyed in reverse order of initialization before the catch block begins execution. Accessing non-static class members within the catch block results in undefined behavior.

2. Control Flow and Rethrowing The behavior of the catch block in a function-try-block depends strictly on the type of function it is applied to:

• Constructors: Reaching the end of the catch block causes the compiler to implicitly rethrow the caught exception. A return statement inside the catch block of a constructor’s function-try-block is strictly ill-formed and will result in a compilation error. The exception cannot be suppressed; you can only replace it by explicitly throwing a different exception.
• Destructors: Reaching the end of the catch block implicitly rethrows the exception. However, a return; statement is perfectly valid inside a destructor’s function-try-block. Executing return; successfully suppresses the exception by preventing control flow from reaching the end of the handler.
• Regular Functions: Reaching the end of the catch block does not implicitly rethrow the exception. If the function has a void return type, execution returns to the caller normally. If the function has a non-void return type, flowing off the end of the catch block without a return statement results in undefined behavior.

3. Parameter Construction Exceptions A function-try-block does not catch exceptions thrown during the evaluation of the function’s arguments or during the copy/move construction of the function parameters themselves. Those exceptions occur in the caller’s context before the function-try-block is entered.

Master C++ with Deep Grasping Methodology!

Learn More