Исключения

try/catch/throw, иерархия std::exception, noexcept и гарантии безопасности исключений — обработка ошибок в C++.

IT Abyss

Исключения — механизм через раскрутку стека

Исключения в C++ — это не «как в Java/Python с другим синтаксисом». Это механизм, неотделимый от раскрутки стека и RAII: язык гарантирует освобождение ресурсов через деструкторы локалов на пути от throw до catch. Без RAII раскрутка работает «через объекты», но сами ресурсы текут. С RAII — наоборот, всё освобождается само.

C++ оставляет много свободы: можно отключить исключения целиком (-fno-exceptions), можно выразить «ожидаемые» ошибки через std::optional/std::expected, можно выбирать гарантии безопасности (nothrow / strong / basic). Ловушки тоже принципиальные: бросок в деструкторе или noexcept-функции — мгновенный std::terminate; move без noexcept отключает оптимизации в std::vector; throw e; вместо throw; теряет тип.

Карта темы

try/catch — базовый синтаксис — как пишутся try, catch, throw, какие ошибки нельзя глотать.
Throw by value, catch by reference — каноничное правило C++: бросать по значению, ловить по const&.
Иерархия std::exception — стандартные классы и собственные исключения через наследование.
Каскад catch — порядок обработчиков, catch(...) и иерархическая ловля.
Раскрутка стека — что делают исключения «снизу вверх», что прерывает раскрутку.
RAII — захват ресурса в конструкторе — почему исключения без RAII опасны; «нет голого владения».
noexcept — контракт «не бросает» — функциональный атрибут, не косметика; влияет на std::vector.
Гарантии безопасности — уровни Саттера (nothrow/strong/basic/none), copy-and-swap.
Деструктор и исключения — двойной бросок → std::terminate; как обрабатывать опасные операции.
Исключения в конструкторах — деструктор не вызовется; глобалы и std::terminate.
Повторный бросок и std::exception_ptr — throw; без операнда, передача между потоками.
Runtime-ошибки — что именно бросает стандартная библиотека и что — нет.
Альтернативы исключениям — optional, expected, error_code, -fno-exceptions.
Стратегия обработки ошибок — где исключения, где value-based, как декларировать контракт.

Частые ошибки и ловушки

Ошибка	Последствие
Ловля по значению (`catch (std::exception e)`)	Срезка — производный тип потерян, виртуальные методы не работают
Пустой `catch(...) {}` без `throw;`	Ошибка молча проглочена, потеряна навсегда
`throw e;` вместо `throw;`	Копия как базовый тип — теряется производный класс
Базовый тип в `catch` выше конкретного	Конкретный обработчик — недостижимый код
Бросок в деструкторе во время раскрутки	Немедленный `std::terminate`
Бросок из `noexcept`-функции	Немедленный `std::terminate`, без раскрутки
Move-конструктор без `noexcept`	`std::vector` копирует вместо move при realloc
Сырой `new` в init-list или теле конструктора	Утечка при исключении в последующей строке
Бросок в конструкторе глобала / static	`std::terminate` — нет окружающего `try`
Исключения как control flow на hot path	На порядок дороже условных ветвей
`try/catch` вокруг `noexcept` операций	Мёртвый код; маскирует баги

Значение для собеседований

Исключения — тема, где интервьюер быстро отличает поверхностное знание от глубокого. Синтаксис try/catch знают все; настоящие вопросы начинаются после.

Что реально проверяется:

Связка раскрутки стека и RAII — почему одно без другого ломается.
Гарантии безопасности (nothrow/strong/basic) и как реализуется strong через copy-and-swap.
Почему noexcept функционален: std::vector realloc выбирает move только при noexcept.
Что вызывает std::terminate — три-четыре сценария наизусть.
Чем throw; отличается от throw e; и почему первое сохраняет тип.
Когда стоит использовать std::optional/std::expected вместо исключений.

Популярные вопросы:

Объясните stack unwinding. Что происходит с локальными объектами?
Какие гарантии безопасности исключений вы знаете? Реализуйте strong для operator=.
Почему move-конструктор должен быть noexcept?
Что вызывает std::terminate()? Назовите минимум три случая.
Как передать исключение из дочернего потока в основной?
Чем throw; отличается от throw e;?
Когда исключения — неподходящий инструмент?

Частая ошибка кандидата: считать исключения «как в Java/Python, только с другим синтаксисом». В C++ они неотделимы от RAII и раскрутки стека — без понимания этой связи ответы будут поверхностными.

intermediate

Exceptions

try/catch/throw, the std::exception hierarchy, noexcept, and exception safety guarantees — error handling in C++.

Exceptions

Practice: 25 questions →

Sections

Contents

Detailed explanation

Exceptions — a mechanism built on stack unwinding

C++ exceptions are not "Java/Python exceptions with different syntax". They are a mechanism inseparable from stack unwinding and RAII: the language guarantees resource release through destructors of locals on the path from throw to catch. Without RAII, unwinding still runs "through objects" — but resources themselves leak. With RAII, everything is released automatically.

C++ also gives you a wide design space: you can disable exceptions entirely (-fno-exceptions), express "expected" failures via std::optional/std::expected, and pick a safety guarantee per operation (nothrow / strong / basic). The traps are principled too: throwing from a destructor or noexcept function is an instant std::terminate; a move without noexcept disables vector optimizations; throw e; instead of throw; loses the dynamic type.

Topic map

try/catch — basic syntax — how try, catch, throw are written; which errors must not be swallowed.
Throw by value, catch by reference — the canonical C++ rule.
std::exception hierarchy — standard classes; deriving your own exceptions.
Catch chain — handler order, catch(...), polymorphic catching.
Stack unwinding — what exceptions do on the way out; what breaks unwinding.
RAII — acquire in constructor — why exceptions without RAII are dangerous; the "no bare ownership" rule.
noexcept — the "does not throw" contract — functional, not cosmetic; impacts std::vector.
Exception safety guarantees — Sutter's levels (nothrow/strong/basic/none), copy-and-swap.
Destructor safety — double-throw → std::terminate; handling potentially-throwing cleanup.
Constructor exception safety — the destructor will not run; globals and std::terminate.
Rethrow and std::exception_ptr — bare throw;, propagation across threads.
Runtime errors — what the standard library throws and what it does not.
Error alternatives — optional, expected, error_code, -fno-exceptions.
Error handling strategy — where exceptions, where value-based; declaring the contract.

Common traps

Mistake	Consequence
Catch by value (`catch (std::exception e)`)	Slicing — derived type lost, virtual methods broken
Empty `catch(...) {}` without `throw;`	Error silently swallowed, lost forever
`throw e;` instead of `throw;`	Copied as the static type — derived class discarded
Base type in `catch` above the specific type	The specific handler is dead code
Throwing from a destructor during unwinding	Immediate `std::terminate`
Throwing from a `noexcept` function	Immediate `std::terminate`, no unwinding
Move constructor without `noexcept`	`std::vector` copies instead of moving on realloc
Raw `new` in init list or constructor body	Leak if a later step throws
Throwing from a global / static constructor	`std::terminate` — no surrounding `try`
Using exceptions as control flow on hot paths	An order of magnitude more expensive than branches
`try/catch` around `noexcept` operations	Dead code; hides bugs

Interview relevance

Exceptions are a topic where interviewers quickly tell shallow knowledge from real depth. Everyone knows try/catch syntax; the real questions start after.

What is actually being checked:

The link between unwinding and RAII — why one without the other breaks.
Safety guarantees (nothrow/strong/basic) and how strong is implemented via copy-and-swap.
Why noexcept is functional: std::vector realloc picks move only when noexcept.
What triggers std::terminate — three or four cases by heart.
Why throw; is different from throw e; and how the first preserves the dynamic type.
When to choose std::optional/std::expected over exceptions.

Popular questions:

Explain stack unwinding. What happens to locals?
Which exception safety guarantees do you know? Implement strong guarantee for operator=.
Why must move constructor be noexcept?
What triggers std::terminate()? Name at least three cases.
How do you pass an exception from a worker thread to the main thread?
How is throw; different from throw e;?
When are exceptions the wrong tool?

Common candidate mistake: treating exceptions as "the Java/Python thing with different syntax". In C++ they are inseparable from RAII and stack unwinding — answers without that connection stay shallow.

Why it matters

C++ exceptions are inseparable from RAII and stack unwinding. Understanding the connection is what separates surface-level knowledge from real exception-safety skill.