Exceptions: throw, catch, noexcept

Throwing exceptions

You can throw any copyable value, but the convention is to throw objects derived from std::exception. The standard library provides a rich hierarchy of exception types in <stdexcept>. When an exception is thrown, stack unwinding begins: every local variable in every function on the call stack between the throw and the catch has its destructor called.

#include <stdexcept>

double divide(double a, double b) {
    if (b == 0.0)
        throw std::invalid_argument("division by zero");
    return a / b;
}

// Standard exception hierarchy (all in <stdexcept>):
// std::exception
//   std::logic_error      — programming errors, detectable before runtime
//     std::invalid_argument
//     std::out_of_range
//     std::length_error
//   std::runtime_error    — errors detectable only at runtime
//     std::overflow_error
//     std::underflow_error
//     std::range_error

Catching exceptions

A try block surrounds code that might throw. One or more catch blocks follow, each matching a specific exception type. Catch handlers are tried in order — the first match wins. Catch by const& to avoid slicing and unnecessary copies. A final catch(...) catches any exception type.

try {
    double result = divide(10.0, 0.0);
    std::cout << result;
}
catch (const std::invalid_argument& e) {
    std::cerr << "Invalid argument: " << e.what() << "\n";
}
catch (const std::runtime_error& e) {
    std::cerr << "Runtime error: " << e.what() << "\n";
}
catch (const std::exception& e) {
    std::cerr << "Unknown std exception: " << e.what() << "\n";
}
catch (...) {
    std::cerr << "Completely unknown exception\n";
    throw;   // re-throw if you can't handle it
}

Derived exception types must be caught before their base classes — catching std::exception before std::invalid_argument would match the derived type in the base-class handler (since derived IS-A base), shadowing the more specific handler. Always put more specific types first.

Custom exception types

Define custom exception classes by inheriting from std::exception or one of its subclasses. Override what()to return a descriptive message. This lets callers catch your library's exceptions specifically.

class DatabaseError : public std::runtime_error {
public:
    explicit DatabaseError(const std::string& msg, int code)
        : std::runtime_error(msg), errorCode_(code) {}

    int errorCode() const { return errorCode_; }

private:
    int errorCode_;
};

// Catch specifically:
try {
    db.query("SELECT * FROM users");
}
catch (const DatabaseError& e) {
    std::cerr << "DB error " << e.errorCode() << ": " << e.what() << "\n";
}

noexcept — marking functions that don't throw

The noexcept specifier declares that a function will never throw. If a noexcept function does throw, std::terminate() is called immediately — no stack unwinding. This allows the compiler and standard library to apply optimizations: std::vectorwill use the move constructor instead of the copy constructor only if the move is noexcept.

// Mark functions that cannot throw:
void swap_ints(int& a, int& b) noexcept {
    int tmp = a; a = b; b = tmp;
}

// Move operations should always be noexcept when possible:
class Buffer {
public:
    Buffer(Buffer&& other) noexcept : data_(other.data_), size_(other.size_) {
        other.data_ = nullptr; other.size_ = 0;
    }
    Buffer& operator=(Buffer&&) noexcept;
    // ...
};

// noexcept(expr) — conditional noexcept based on another expression:
template<typename T>
void my_swap(T& a, T& b) noexcept(std::is_nothrow_move_constructible_v<T> &&
                                   std::is_nothrow_move_assignable_v<T>) {
    T tmp = std::move(a);
    a = std::move(b);
    b = std::move(tmp);
}

When to use exceptions vs alternatives

Key rules to remember