FREE PRACTICAL C++ GUIDE
How should a C++ function report failure?
Should it throw an exception, return an explicit error, or terminate because the program has violated its own contract?
This practical guide explains how exceptions and std::expected propagate failures through a C++ application, what trade-offs each model introduces, and how to choose an approach that fits the API you are designing.
Get the Free Guide
Error Handling Is More Than throw vs. std::expected
The mechanism you choose affects more than syntax.
It changes how control flows through the application, what callers can see in an API, where failures are handled, and what guarantees your code must preserve when something goes wrong.
This guide builds a practical model for making those decisions deliberately.
What You’ll Learn
Recoverable Failure vs. Programming Error
Learn to distinguish failures another layer may reasonably handle from violated contracts and broken program invariants.
How Exceptions Actually Propagate
Understand try, catch, stack unwinding, matching handlers, and the non-local control flow created by exceptions.
RAII and Exception Safety
See why resource ownership must remain correct even when a function does not return normally.
Exception-Safety Guarantees and noexcept
Understand the basic, strong, and no-throw guarantees and what noexcept really promises as part of an API contract.
Explicit Errors with std::expected
std::expectedLearn how std::expected<T, E> makes failure visible in a function’s return type and gives callers explicit control over handling and propagation.
Choosing an Error Model at an API Boundary
Learn when exceptions are a natural fit, when explicit error values make more sense, and why consistency matters more than choosing one mechanism everywhere.
What’s Inside the Guide
The guide walks through:
- recoverable failures and programming errors;
- exception propagation and matching handlers;
- RAII and stack unwinding;
- exception-safety guarantees;
noexceptas part of an API contract;- explicit error propagation with
std::expected; [[nodiscard]]for error-returning APIs;- exceptions vs. explicit error values;
- choosing a consistent error model at architectural boundaries.
Make Error Handling Part of Your API Design
Good error handling does more than report that something failed.
It keeps program invariants intact, preserves useful error information, and gives the appropriate layer enough information to decide what should happen next.
Get the complete practical guide and build a clearer mental model for error propagation in modern C++.
By entering your email and confirming your subscription, you’ll receive the free CMake guide and subscribe to From Complexity to Essence in C++. One email per month. Unsubscribe anytime.
To complete your subscription:
- Open the confirmation email we just sent.
- Click Confirm to receive your PDF right away.
If the message doesn’t show up, please check Spam/Promotions.
That’s it.
A clean PDF with practical examples — plus one useful email per month to help you build better C++ software.