C++ Exceptions: throw, what(), and Error Handling

Why Exceptions Exist

On the previous page you used enum class to give error states meaningful names. That's great for outcomes a function expects and the caller is supposed to inspect. But some failures are different: a function deep in your call stack discovers that a file won't open, or that an argument makes no sense, and it has no idea what the program should do about it. Returning an error code only works if every caller in the chain remembers to check it and pass it up. Miss one check and the program sails on with garbage.

Exceptions solve this. When something goes wrong, you throw an object. Execution stops immediately, the stack unwinds (every local object between the throw and the handler has its destructor run), and control jumps to the nearest matching catch. An unhandled exception can't be silently ignored - if nothing catches it, the program calls std::terminate and aborts.

#include <iostream>
#include <stdexcept>
using namespace std;

int divide(int a, int b) {
    if (b == 0) {
        throw runtime_error("division by zero");
    }
    return a / b;
}

int main() {
    try {
        cout << divide(10, 2) << "\n";   // 5
        cout << divide(10, 0) << "\n";   // throws before printing
    } catch (const runtime_error& e) {
        cout << "caught: " << e.what() << "\n";
    }
    return 0;
}

This page focuses on the throwing side - the error objects themselves. The next page digs into the try/catch machinery in detail.

Throwing and the what() Message

You can technically throw any value - throw 42; or throw "oops"; are legal - but don't. The convention everyone follows is to throw an object derived from std::exception. That base class declares one virtual method, what(), returning a const char* description of the problem. Sticking to the convention means a single catch (const std::exception& e) can handle anything.

The <stdexcept> header gives you ready-made types whose constructor takes the message:

#include <iostream>
#include <stdexcept>
#include <string>
using namespace std;

int main() {
    string user = "guest";
    try {
        throw runtime_error("user '" + user + "' is not authorized");
    } catch (const exception& e) {
        cout << e.what() << "\n";   // user 'guest' is not authorized
    }
    return 0;
}

Notice what() returns the exact string you constructed the exception with. Notice too that we caught by const exception& even though we threw a runtime_error - that works because runtime_error is a std::exception (a relationship you'll recognize from the inheritance page).

The Standard Exception Hierarchy

Before writing your own exception type, check whether the standard library already has one that fits. They all inherit from std::exception and split into two families in <stdexcept>:

• logic_error - a bug in the program's logic that could, in principle, be caught before running. Subtypes include invalid_argument, out_of_range, domain_error, and length_error.
• runtime_error - a failure that only shows up at runtime and isn't a programming mistake per se. Subtypes include range_error, overflow_error, and underflow_error.

Many library functions throw these for you. For example, the vector container's at() does bounds checking and throws out_of_range instead of letting you read past the end:

#include <iostream>
#include <vector>
#include <stdexcept>
using namespace std;

int main() {
    vector<int> v = {10, 20, 30};

    try {
        cout << v.at(1) << "\n";   // 20
        cout << v.at(9) << "\n";   // out of range -> throws
    } catch (const out_of_range& e) {
        cout << "bad index: " << e.what() << "\n";
    }
    return 0;
}

That at() is the safe counterpart of v[9]. The plain operator[] does no bounds check - reading v[9] here is undefined behavior, not an exception. Choosing at() is how you turn a silent corruption into a catchable error.

Pick the type that describes the error: invalid_argument when a caller passes something nonsensical, out_of_range for index/key problems, runtime_error for "the outside world failed on me."

#include <iostream>
#include <stdexcept>
#include <cmath>
using namespace std;

double safe_sqrt(double x) {
    if (x < 0) {
        throw invalid_argument("safe_sqrt: x must be non-negative");
    }
    return sqrt(x);
}

int main() {
    try {
        cout << safe_sqrt(16) << "\n";   // 4
        cout << safe_sqrt(-1) << "\n";   // throws
    } catch (const invalid_argument& e) {
        cout << "error: " << e.what() << "\n";
    }
    return 0;
}

Writing Your Own Exception Type

When no standard type fits - you want to attach extra data, or catch your error specifically and nothing else - define a class that inherits from std::exception (or one of its subtypes) and override what(). Inheriting from std::runtime_error is the easiest route because it already stores the message and implements what() for you:

#include <iostream>
#include <stdexcept>
#include <string>
using namespace std;

class NetworkError : public runtime_error {
    int status_;
public:
    NetworkError(int status, const string& msg)
        : runtime_error(msg), status_(status) {}

    int status() const { return status_; }
};

int main() {
    try {
        throw NetworkError(503, "service unavailable");
    } catch (const NetworkError& e) {
        cout << "HTTP " << e.status() << ": " << e.what() << "\n";
    } catch (const exception& e) {
        cout << "other error: " << e.what() << "\n";
    }
    return 0;
}

Because NetworkError carries a status code, the handler can react to it - retry on a 5xx, give up on a 4xx. A bare error string couldn't do that. The custom type also lets a catch (const NetworkError&) grab only network problems and leave everything else to the more general handler below it.

If you ever inherit straight from std::exception (not runtime_error), remember to override what() yourself, and mark it noexcept to match the base signature:

class ParseError : public std::exception {
public:
    const char* what() const noexcept override {
        return "failed to parse input";
    }
};

Throw by Value, Catch by Reference

This is the single most important rule of C++ exceptions, and the one beginners get wrong. Throw objects by value and catch them by const reference.

throw runtime_error("oops");            // by value - correct
catch (const runtime_error& e) { ... }  // by const reference - correct

Catching by value instead - catch (std::exception e) - copies the exception into a base-class object and slices off the derived part. After slicing, e.what() calls the base implementation, not your overridden one, so your carefully crafted message disappears:

try {
    throw NetworkError(503, "service unavailable");
} catch (std::exception e) {       // by value - object slicing!
    std::cout << e.what();         // generic message, status() is gone
}

The reference (&) preserves the real dynamic type, so virtual what() dispatches correctly and you can still access derived members. Add const because you're only reading the exception, not modifying it. Never throw a pointer (throw new runtime_error(...)) - the catcher would have to delete it, and on which code path? That's exactly the leak exceptions are supposed to prevent.

Next: try-catch

You can now create and throw well-formed exceptions and choose the right standard type for each failure. The other half of the story is the catching side. The next page covers try/catch in full: ordering multiple catch blocks from most-specific to most-general, the catch-all catch (...), re-throwing with a bare throw;, and how RAII (think back to smart pointers) guarantees your resources are released as the stack unwinds.