Exception Handling in C++ — try, catch, throw and Real-World Patterns

Software breaks. Not because developers are careless — but because the real world is unpredictable. A file your program needs gets deleted by the user. A network call times out at 2 AM. A user types their age as 'banana'. These aren't bugs in your logic; they're edge cases that exist at the boundary between your code and reality. Without a structured way to handle them, your program either crashes loudly with a segfault, or worse, silently produces wrong results. Neither is acceptable in production software.

C++ gives you exception handling — a formal, structured mechanism to separate the 'happy path' code from the 'something went wrong' code. Before exceptions existed, C programs (and early C++) handled errors by returning special integer codes like -1 or NULL. Every caller had to manually check those return values, and if even one layer forgot, the error disappeared silently up the call stack. Exceptions changed that: an error thrown deep in a library function can't be silently ignored — it will unwind the call stack until something explicitly catches it, or terminate the program making the problem impossible to miss.

By the end of this article you'll understand not just the syntax of try, catch, and throw, but WHY they work the way they do, how stack unwinding protects your resources, how to design your own exception hierarchy for real projects, and the exact mistakes that trip up even experienced C++ developers. You'll be able to write exception-safe code and explain the design choices behind it in an interview.

The Core Mechanic — try, throw, and catch in Plain English

The three keywords work as a team. You wrap risky code in a try block — code that might fail. If something goes wrong inside that block, you throw an exception object. Control immediately jumps out of the try block and into the matching catch block. Nothing between the throw site and the catch runs.

This separation is the whole point. Your normal logic stays clean inside the try block. Your error-handling logic lives in catch. They never tangle together with nested if-checks.

The thing you throw can be almost anything — an integer, a string, or (the right approach) an object from a class. In practice, you should always throw objects, not primitives, because objects can carry rich context: a message, an error code, the filename where the error happened. Throwing an int like -1 leaves the catcher with no context about what went wrong.

#include <iostream>
#include <stdexcept>
#include <string>

namespace io::thecodeforge::exceptions {

int parseAge(const std::string& rawInput) {
    // std::stoi throws invalid_argument or out_of_range internally
    int age = std::stoi(rawInput);

    if (age < 0 || age > 150) {
        throw std::out_of_range("Age must be 0-150, got: " + rawInput);
    }
    return age;
}

}

int main() {
    try {
        int age = io::thecodeforge::exceptions::parseAge("300");
        std::cout << "Age: " << age << "\n";
    } catch (const std::invalid_argument& e) {
        std::cerr << "Format Error: " << e.what() << "\n";
    } catch (const std::out_of_range& e) {
        std::cerr << "Range Error: " << e.what() << "\n";
    } catch (const std::exception& e) {
        std::cerr << "Generic Error: " << e.what() << "\n";
    }
    return 0;
}

Stack Unwinding — How C++ Cleans Up After an Exception

When an exception is thrown, C++ systematically destroys every local object between the throw site and the catch block, in reverse order of construction. This process is called stack unwinding.

This is the foundation of RAII (Resource Acquisition Is Initialization). If you use stack-allocated RAII wrappers like std::unique_ptr or std::lock_guard, their destructors run during unwinding even if an exception interrupts your function. This prevents memory leaks and stale locks without requiring manual cleanup code in every catch block.

#include <iostream>
#include <memory>
#include <stdexcept>
#include <string>

namespace io::thecodeforge::resources {

class DatabaseConnection {
public:
    explicit DatabaseConnection(const std::string& host) : host_(host) {
        std::cout << "[DB] Connected to " << host_ << "\n";
    }
    ~DatabaseConnection() {
        std::cout << "[DB] Connection to " << host_ << " closed cleanly.\n";
    }
    void query(const std::string& sql) {
        if (sql.find("DROP") != std::string::npos) {
            throw std::runtime_error("Forbidden query: " + sql);
        }
    }
private:
    std::string host_;
};

void runTask() {
    auto db = std::make_unique<DatabaseConnection>("prod-db-01");
    db->query("DROP TABLE users"); // Throws
}

}

int main() {
    try {
        io::thecodeforge::resources::runTask();
    } catch (const std::exception& e) {
        std::cerr << "Caught: " << e.what() << "\n";
    }
    return 0;
}

Frequently Asked Questions