Skip to main content

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.

A try block is a compound statement that establishes an exception-handling context for the execution of its enclosed statements. It dictates that if an exception is thrown during the execution of the block—either directly via a throw expression or indirectly via a called function—control flow will be transferred to the appropriate catch handler associated with that specific try block. 
#include <iostream>
#include <stdexcept>

class SpecificExceptionType : public std::runtime_error {
public:
    SpecificExceptionType() : std::runtime_error("Specific exception occurred") {}
};

int main() {
    try {
        // Statements executed within the exception-handling context
        throw SpecificExceptionType();
    } 
    catch (const SpecificExceptionType& e) {
        // Handler for SpecificExceptionType
        std::cout << "Caught specific exception: " << e.what() << '\n';
    } 
    catch (const std::exception& e) {
        // Handler for standard exceptions
        std::cout << "Caught standard exception: " << e.what() << '\n';
    }
    catch (...) {
        // Ellipsis (...) denotes a catch-all handler for any exception type
        std::cout << "Caught unknown exception\n";
    }
    return 0;
}

​
Structural Mechanics

Mandatory Association A try block cannot exist in isolation. It must be immediately followed by one or more catch blocks. The compiler enforces this structural requirement; intervening statements between a try block and its catch handlers result in a syntax error. Handler Ordering and Catch-All catch blocks are evaluated in the exact order they appear. Because of this linear evaluation, a catch-all handler (catch (...)) must be the very last handler in a try-catch sequence. Placing catch (...) before other specific catch blocks results in a compilation error, as it would unconditionally intercept all exceptions and render any subsequent handlers unreachable. Scope and Lifetime The try block defines a distinct lexical scope. Variables declared within the try block are local to that block. If an exception is thrown, these local variables are destroyed during the stack unwinding process before control enters the catch block. Consequently, variables declared inside the try block are strictly inaccessible to its corresponding catch handlers. Exception Propagation and Stack Unwinding C++ exception handling utilizes a two-phase process when an exception is thrown:
  1. Search Phase: The runtime searches the call stack for a matching catch handler before any stack unwinding occurs. It checks the immediate try block, and if no match is found, it propagates the search outward to dynamically enclosing try blocks across the call stack.
  2. Unwind Phase: If a matching handler is found, the runtime initiates stack unwinding up to the scope of that handler. The destructors of all fully constructed automatic objects within the unwound scopes are invoked in the reverse order of their construction. Control is then transferred to the matching catch block.
If the search phase fails to find a matching handler anywhere in the call stack, the runtime calls std::terminate(). In this scenario, it is implementation-defined whether the stack is unwound at all.

​
Function-Try-Blocks

C++ provides a specialized variant called a function-try-block, which wraps an entire function body, including constructor member initializer lists. This is the only mechanism available to catch exceptions thrown during the initialization of base classes or class members. 
#include <iostream>
#include <stdexcept>

class MemberType {
public:
    MemberType(int value) {
        if (value < 0) {
            throw std::invalid_argument("Negative value not allowed");
        }
    }
};

class MyClass {
    MemberType member;
public:
    MyClass(int value) 
    try : member(value) {
        // Constructor body
        std::cout << "Constructor body executing.\n";
    } 
    catch (const std::exception& e) {
        // Handles exceptions thrown by MemberType's constructor 
        // OR the MyClass constructor body.
        std::cout << "Caught exception in function-try-block: " << e.what() << '\n';
        // Note: The exception is implicitly rethrown at the end of this block.
    }
};

int main() {
    try {
        MyClass obj(-1); // Triggers the exception in MemberType
    } catch (...) {
        std::cout << "Caught implicitly rethrown exception in main.\n";
    }
    return 0;
}
In a constructor function-try-block, if a catch handler is invoked, the object is considered partially constructed and its lifetime never begins. Control cannot return to the caller normally; the handler must either throw a different exception or allow the original exception to be implicitly rethrown at the end of the catch block.
Master C++ with Deep Grasping Methodology!Learn More