Exceptions

When an exception leaves a scope, C++ destroys fully constructed automatic objects in reverse order until a matching catch is found. RAII relies on this: destructors release files, locks, memory, and other resources during unwinding.

Throw copies (or moves) the object into a runtime area, so throwing a pointer to a local dangles and throwing a base by value slices. Catching by reference avoids slicing and a copy; const shows the handler doesn't mutate it.

throw expr unwinds the stack, calling destructors (RAII) until a matching catch is found. Thrown type must equal or publicly derive from caught. Clauses are tried in declaration order — derived before bases. catch(...) matches anything.

If a destructor lets an exception escape while another exception is already being unwound, the program calls std::terminate().

Basic: invariants hold, no leaks, valid state. Strong: complete or roll back, like a transaction. Nothrow: never throws (noexcept). vector::push_back is strong for copyable, basic for move-only. Strong is built via copy-and-swap.

catch (...) is the ellipsis handler that catches any exception type, so it must be the last clause. Its limit: you get no named object, so you cannot inspect the exception directly — only throw; to re-raise it or std::current_exception() to capture it.

Yes. The object's destructor is NOT called (it was never fully constructed), but already-constructed members and bases are destroyed in reverse order and memory is freed. RAII members clean up reliably even on a partial-construction failure.

Root std::exception with virtual const char* what(). Branches: std::logic_error (precondition bugs), std::runtime_error (runtime conditions). Plus std::bad_alloc, std::bad_cast. Derive from the closest base so generic catch works.

assert checks programmer invariants — bugs that shouldn't happen; compiles out in release. Exceptions handle runtime conditions outside the program: I/O, parse errors, OOM. Rule: assert = fix the code; exception = world isn't cooperating.

std::terminate runs on unrecoverable situations: an exception escaping noexcept, a throw during stack unwinding, no matching handler, or a failed exception construction. It calls the current handler — by default std::abort. You replace it with std::set_terminate.

Exceptions: truly exceptional conditions across many frames. Error codes / std::expected (C++23): hot paths, loop-called APIs, -fno-exceptions builds (embedded, kernel), or when failure is normal control flow.

Four levels: no guarantee, basic (no leaks, valid state), strong (commit-or-rollback), no-throw (noexcept). STL containers give strong for single-element ops like push_back, basic for multi-element ones.

If an exception escapes a noexcept function, std::terminate runs immediately — stack may not unwind, destructors may not run, not catchable. The intent: let compilers optimise (especially moves) by skipping exception tables.

Bare throw; re-raises the active exception without copying — the original dynamic type is preserved, key when re-throwing through a base-class catch. throw e; copies e and slices to the static type if e is a value.

Integer division by zero is UB — may crash or trigger SIGFPE, NOT catchable via try/catch. Validate first: if (b == 0) throw std::domain_error(...);. Floating-point follows IEEE 754: yields +inf, -inf, or NaN, no signal.

Default new throws std::bad_alloc on failure; new(std::nothrow) T returns nullptr. On Linux with overcommit, OOM-killer fires later, so catching is unreliable. Strategies: preallocate, install set_new_handler, or use non-throwing allocators.

std::expected<T, E> (C++23) holds either a value or an error E inline, with no allocation and no unwinding. Failure is an ordinary return checked via has_value(). Unlike exceptions, the error path costs the same as success and is visible in the signature.

Catch handlers are tried in source order, not best match — first type that accepts the throw wins. More-derived must come before bases, else the base catches and the derived is dead code. catch(...) is always last.

Old dynamic specs like throw(int) were checked at runtime and called std::unexpected on violation — costly and rarely useful. C++11 added noexcept (a no-throw contract), deprecated dynamic specs, made throw() equivalent to noexcept, and C++17 removed them entirely.

On Itanium ABI (Linux/macOS) the no-throw path is essentially free. Throwing is costly: DWARF walk, destructor calls, object allocation. Windows SEH has a small per-function setup. Throws run ~10-1000× slower than error codes.

No. Stack overflow is an OS signal (SIGSEGV on Linux, access violation on Windows), not a C++ exception. The runtime cannot unwind without stack space. Windows SEH can intercept the page fault, but that is not portable C++.

std::exception_ptr is a shared, type-erased smart pointer to a copy of an exception. In catch, current_exception() returns one; rethrow_exception(p) re-raises it elsewhere. std::promise::set_exception delivers worker errors to a future.

A function-try-block wraps the whole body of a function and, for constructors, also the member-initialiser list. Its unique value is catching throws during member init. The handler can clean up but cannot suppress — runtime rethrows.

std::nested_exception attaches a captured prior exception to a new one to preserve a cause chain. throw_with_nested(e) throws e mixed with nested_exception plus the active exception. rethrow_if_nested(p) re-raises the cause.

std::uncaught_exceptions() (C++17) returns the count of in-flight uncaught exceptions on this thread. Used in destructors to detect unwinding — ScopeGuard rolls back if the count is higher than at construction.