Exceptions, throw, and the cost of throwing

Understanding Exceptions, throw, and the cost of throwing

A throw-expression does not hand over the object you name; it copy-initializes a new object, the exception object, into storage the runtime owns. That storage has to live outside the throwing frame because that frame is about to disappear, so libstdc++ and libc++ go through __cxa_allocate_exception, which normally reaches malloc and falls back to a small emergency buffer when memory is exhausted. The type of the exception object comes from the static type of the operand, not from the dynamic type behind it, which is why throw Derived{} produces a Derived while throw e; inside catch (const Base& e) produces a Base. Throwing a temporary is the most predictable form: since C++17 a prvalue operand initializes the exception object directly, so no copy constructor runs at all.

On the ordinary path a throw costs nothing, and that is literal: with table-driven unwinding the compiler emits no instructions to enter or leave a try block and no flag to test on return. What it emits instead is static data, .gcc_except_table entries plus landing-pad code parked in a cold section, so the price of exception support is binary size and some lost optimization freedom, not time per call. The bill arrives at the throw: the runtime allocates the exception object, then walks the stack twice, first asking each frame's personality routine whether it has a matching handler (std::type_info comparisons, sometimes string comparisons across shared-library boundaries), then walking again to run cleanups and jump into the chosen landing pad. That is why a caught throw usually lands in the microsecond range while a plain return is a nanosecond or two, and the gap widens with the number of frames and destructors between the throw and the handler.

So throw is a pay-per-use feature with a large, mostly fixed per-event price, and the only question that matters is how often the event fires. Three failures per ten million records are free in practice; a throw for every missing key in a lookup loop or every non-digit in a parser turns a nanosecond decision into a microsecond one and shows up immediately in a throughput profile. Part of the cost is outside your control: the first throw in a process may pay to locate unwind tables for the loaded objects, and finding those tables per frame does not scale well when many threads throw at once, so real throughput can be worse than a single-threaded measurement suggests. Use throw when the caller almost certainly cannot continue, and keep the thrown type small so allocating and copying it stays cheap.

#include <iostream>
#include <string>
#include <utility>

struct Failure {
    std::string detail;

    explicit Failure(std::string d) : detail(std::move(d)) {
        std::cout << "Failure built\n";
    }
    Failure(const Failure& other) : detail(other.detail) {
        std::cout << "Failure copied\n";
    }
    ~Failure() { std::cout << "Failure destroyed\n"; }
};

const Failure* first_seen = nullptr;

void write_block() {
    throw Failure("disk full");   // prvalue: built straight into the exception object
}

void save() {
    try {
        write_block();
    } catch (const Failure& e) {
        first_seen = &e;
        std::cout << "save() saw: " << e.detail << "\n";
        throw;                    // the same object continues; nothing is copied
    }
}

int main() {
    try {
        save();
    } catch (const Failure& e) {
        std::cout << "main() saw: " << e.detail << "\n";
        std::cout << "same object: " << (&e == first_seen ? "yes" : "no") << "\n";
    }
    std::cout << "after the handler\n";
}

Worked examples

#include <iostream>

struct Base {
    virtual const char* name() const { return "Base"; }
    virtual ~Base() = default;
};

struct Derived : Base {
    const char* name() const override { return "Derived"; }
};

void keeps_type() {
    try {
        throw Derived{};
    } catch (const Base&) {
        throw;                 // rethrow: still the same Derived object
    }
}

void loses_type() {
    try {
        throw Derived{};
    } catch (const Base& e) {
        throw e;               // new exception object, static type Base
    }
}

int main() {
    try { keeps_type(); }
    catch (const Base& e) { std::cout << "after throw;   " << e.name() << "\n"; }

    try { loses_type(); }
    catch (const Base& e) { std::cout << "after throw e; " << e.name() << "\n"; }
}

#include <chrono>
#include <iostream>
#include <stdexcept>

bool check_return(int i) { return i % 7 != 0; }   // false means failure

void check_throw(int i) {
    if (i % 7 == 0) throw std::runtime_error("bad input");
}

int main() {
    const int n = 200000;
    int failed_return = 0, failed_throw = 0;

    auto t0 = std::chrono::steady_clock::now();
    for (int i = 0; i < n; ++i)
        if (!check_return(i)) ++failed_return;
    auto t1 = std::chrono::steady_clock::now();

    for (int i = 0; i < n; ++i) {
        try { check_throw(i); }
        catch (const std::runtime_error&) { ++failed_throw; }
    }
    auto t2 = std::chrono::steady_clock::now();

    using us = std::chrono::microseconds;
    auto plain  = std::chrono::duration_cast<us>(t1 - t0).count();
    auto thrown = std::chrono::duration_cast<us>(t2 - t1).count();

    std::cout << "failures found: " << failed_return << " and " << failed_throw << "\n";
    std::cout << "throwing loop at least 20x slower: "
              << (thrown > 20 * plain ? "yes" : "no") << "\n";
}

#include <cstdlib>
#include <exception>
#include <iostream>

void bail() {
    std::cout << "terminate handler called\n";
    std::exit(0);          // a terminate handler must not return
}

int main() {
    std::set_terminate(bail);
    std::cout << "about to rethrow with nothing in flight\n";
    throw;
}

Important notes

Common mistakes

Try it yourself