Exceptions: throw, try, catch and noexcept

Why exceptions?

Errors happen: a file is missing, a network call times out, a user types letters for an amount. Returning error codes means every caller must check every result, and it is easy to forget. An exception separates error handling from normal code: the function that detects a problem throws, and a function higher up that knows what to do catches. Constructors, which have no return value, can only report failure this way.

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

double withdraw(double balance, double amount) {
    if (amount <= 0) throw std::invalid_argument("amount must be positive");
    if (amount > balance) throw std::runtime_error("insufficient balance");
    return balance - amount;
}

int main() {
    try {
        double left = withdraw(500, 800);
        std::cout << "Left: " << left << '\n';        // skipped
    } catch (const std::invalid_argument& e) {
        std::cout << "Bad input: " << e.what() << '\n';
    } catch (const std::exception& e) {               // any other standard exception
        std::cout << "Error: " << e.what() << '\n';   // Error: insufficient balance
    }
}

How throw and catch work

1. throw creates an exception object and starts searching for a handler.
2. The current function stops. Its local objects are destroyed in reverse order (stack unwinding), so RAII destructors run.
3. The search moves up to the caller, then its caller, until it finds a try block with a matching catch.
4. The catch block runs. The program continues after that try/catch.
5. If no catch matches anywhere, std::terminate is called and the program ends.

The standard exception family

class PaymentError : public std::runtime_error {
public:
    PaymentError(const std::string& msg, int code)
        : std::runtime_error(msg), code_(code) {}
    int code() const noexcept { return code_; }
private:
    int code_;
};

try {
    throw PaymentError("gateway timeout", 504);
} catch (const PaymentError& e) {
    std::cout << e.what() << " (" << e.code() << ")\n";
}

Rules of good exception use

• Throw by value (throw std::runtime_error("...")), catch by const reference (catch (const std::exception& e)). Catching by value slices derived exceptions.
• Order catch blocks from most specific to most general; the first match wins.
• catch (...) catches anything; use it only to log and rethrow (throw;) or at the top of main.
• Use exceptions for exceptional situations, not normal control flow such as "end of loop".
• Never let an exception escape a destructor.

noexcept

Marking a function noexcept promises it will not throw. If it throws anyway, std::terminate is called. Destructors are noexcept by default. Mark move constructors, move assignments and swap functions noexcept: as you saw, std::vector uses moves only when they are noexcept.