Ch 9. Exception Handling

4 hours · 5 marks

9.1 Basics of Exception Handling

An exception is a run-time abnormal condition/error (divide by zero, invalid array index, file not found) that disrupts normal program flow. C++ exception handling uses three keywords:

• try — a block containing code that might throw an exception.
• throw — signals that an exceptional condition has occurred, passing an exception object.
• catch — a block that receives and handles a thrown exception of a matching type.

try {
    int a = 10, b = 0;
    if (b == 0) throw runtime_error("Division by zero");
    cout << a / b;
} catch (runtime_error &e) {
    cout << "Caught: " << e.what();
}

9.2 Advantage Over Conventional Error Handling

• Separates error-handling code from normal program logic, improving readability.
• Errors cannot be silently ignored the way an unchecked return code can be — an uncaught exception terminates the program, forcing attention.
• A single catch block can handle errors from many statements/function calls within a try block, avoiding repetitive if-checks after every call.
• Exceptions can carry rich data (an object, not just an error code) describing what went wrong.
• Errors propagate automatically up the call stack until a matching handler is found (stack unwinding), unlike manual error codes that must be checked and re-returned at every level.

9.3 Exception Handling Mechanism

When a throw executes: the program immediately stops normal execution, searches up the call stack for a catch block matching the exception's type, calls destructors for all local objects going out of scope along the way (stack unwinding), then transfers control into the matching catch block. If no matching handler is found anywhere in the call stack, std::terminate() is called and the program aborts.

9.4 Multiple Handlers

A single try block can be followed by multiple catch blocks, each handling a different exception type — the first matching handler (in order) is executed.

try {
    throw 3.14;                  // throws a double
} catch (int e) {
    cout << "int caught";
} catch (double e) {
    cout << "double caught: " << e;   // this one matches
} catch (char e) {
    cout << "char caught";
}

9.5 Catching All Exceptions

The ellipsis handler catch(...) matches any exception type, and is typically placed last as a catch-all fallback for unexpected/unknown exceptions.

try {
    throw "unexpected error";
} catch (int e) {
    cout << "int";
} catch (...) {                 // catches anything not matched above
    cout << "Unknown exception caught";
}

9.6 Rethrowing Exception

A catch block can perform partial handling (e.g., logging) and then re-throw the same exception using a bare throw; so an outer handler can also process it.

try {
    try {
        throw runtime_error("Disk error");
    } catch (runtime_error &e) {
        cout << "Logged: " << e.what();
        throw;                       // rethrow to outer handler
    }
} catch (runtime_error &e) {
    cout << "Outer handler: " << e.what();
}

9.7 Exception with Arguments

A thrown exception can carry data — a simple value, or a full object with multiple fields, describing the error in detail.

class MyException {
public:
    int errorCode;
    string message;
    MyException(int c, string m): errorCode(c), message(m) {}
};
try {
    throw MyException(404, "Not Found");
} catch (MyException &e) {
    cout << e.errorCode << ": " << e.message;
}

9.8 Exception Specification for Function

Older C++ allowed declaring which exceptions a function might throw: void f() throw(int, char); meaning it may only throw int or char. throw() with an empty list meant the function throws nothing. This mechanism is deprecated in modern C++ (C++11 onward) and replaced by the simpler noexcept specifier, which just declares whether a function may throw at all (void f() noexcept;).

9.9 Exceptions in Constructors and Destructors

• A constructor can safely throw an exception if initialization fails (e.g., memory allocation failure, invalid parameter) — since the object was never fully constructed, its destructor will NOT be called, but destructors of any already-fully-constructed sub-objects/base classes will run during stack unwinding.
• A destructor should generally NOT throw exceptions. If an exception is already propagating (stack unwinding) when a destructor throws another one, the program calls std::terminate() immediately, since C++ cannot handle two simultaneous exceptions.

9.10 Handling Uncaught Exceptions

If an exception is thrown but no matching catch block exists anywhere in the call stack, the special function std::terminate() is automatically invoked, which by default calls std::abort(), ending the program immediately (destructors of objects further up the stack are not guaranteed to run).

9.11 Handling Unexpected Exceptions

In the older exception-specification model, if a function threw an exception type not listed in its throw() specification, the special function std::unexpected() was called (which by default also calls terminate()). This mechanism is deprecated in modern C++ along with dynamic exception specifications; noexcept functions that throw now call std::terminate() directly.

Most Probable Questions

#include <iostream>
using namespace std;
int main() {
    try {
        int choice = 2;
        if (choice == 1) throw 10;
        else if (choice == 2) throw 3.14;
        else throw string("error");
    } catch (int e) {
        cout << "Integer exception: " << e;
    } catch (double e) {
        cout << "Double exception: " << e;
    } catch (string &e) {
        cout << "String exception: " << e;
    }
}