Learn C++ by Example (Frances Buontempo)（Z-Library）

【One-Line Pitch】 A hands-on re-entry guide for programmers who once knew C++ and feel left behind by the C++11–23 era: nine small, playful projects (games, simulations, a slot machine) rebuild your fluency one modern feature at a time. Best for returning C++ developers and intermediate programmers who learn by building rather than by reference lookup. 【Book Arc】 - **Opening (~0%–10%)**: Front matter, foreword, and contents set expectations — the book is project-driven, not a language reference, and explicitly targets people overwhelmed by post-C++11 changes. The chapter map previews nine self-contained builds. - **Early (~10%–32%)**: The author's preface and "About this book" explain the teaching philosophy: small projects, iterate on code, compile and play. Chapter 1 argues why C++ still matters and frames the "bootstrap your knowledge" approach; setup and code-repository guidance appear here. - **Middle (~32%–55%)**: Chapters 2–5 move from containers, iterators, and ranges (Pascal's triangle) through input handling with `std::optional`/`std::function`, `std::chrono` countdowns, and class-based card games with scoped enums, `std::array`, three-way comparison, and `std::variant`. - **Late (~55%–85%)**: Chapters 6–8 escalate: inheritance and special member functions with smart pointers and type traits (blob race), `std::map`/`std::multimap` with structured bindings and file input (answer smash), then `std::unordered_map`, `std::hash`, and a coroutine-based "mind reader." - **Ending (~85%–100%)**: Chapter 9 closes with parameter packs, fold expressions, `std::visit`, and `std::views::zip` in a slot-machine project, plus an appendix of further resources — ending on practice suggestions rather than a summary. 【Book Arc note】The excerpts confirm this progression but do not include chapter 1's full text or the appendix contents; percentages are approximate. 【Key Takeaways】 - **Projects are the teaching unit** (Early): each chapter is a self-contained game or toy, so concepts arrive attached to something you can run and modify — the stated reason is retention, not coverage. - **The target reader is a returner, not a beginner** (Early): the author explicitly addresses people who "used to know C++" and are overwhelmed by new features; prior familiarity with `std::vector`, `std::string`, and `std::cin`/`cout` is assumed. - **Modern features are introduced incrementally** (Middle): ranges, lambdas, `std::format`, `std::optional`, `std::variant`, concepts, and coroutines each get a concrete use case rather than a definition-first treatment. - **Iteration is the method** (Early): the foreword stresses that each section shows the "journey of development," revising code as new concepts arrive — the point is watching code evolve, not memorizing final listings. - **Containers anchor the curriculum** (Middle/Late): `std::vector`, `std::array`, `std::map`, `std::multimap`, and `std::unordered_map` recur, with structured bindings and `std::pair`/`std::tuple` making them pleasant to query. - **Object lifetime and ownership get real treatment** (Late): special member functions, the rule of zero, type traits, and smart pointers appear in the blob-race chapter, connecting modern C++ to its memory-management reputation. - **Coroutines are demystified through a game** (Late): the mind-reader example builds a `promise_type` and `Task` type step by step — the book's most advanced material, placed late for good reason. - **Compiler support is acknowledged as uneven** (Early): `std::format` and similar features are flagged where toolchains lag, with fallback comments in the source — a practical honesty rare in language books. 【Reading Tips】 - **Read chapter 1, then set up your compiler before chapter 2** — the author says the games start there, and the code repository (BootstrapCpp) is the intended companion. - **Type the code and run it; don't just read listings.** The foreword and preface both push "learning by doing," and the incremental revisions only make sense if you follow along. - **Chapters can be read out of order but build on each other** — if you're rusty on classes, do chapters 5–6 in sequence; if you want the newest features, jump to 8–9 but expect to backtrack. - **Skim the front matter and appendix; deep-read chapters 2, 6, and 8** if you want the broadest feature coverage (ranges, ownership, coroutines) in the least time. - **Treat compiler warnings and unsupported-feature notes as part of the lesson** — they're where the book quietly teaches portability judgment. 【Coverage Limits】 This guide is based on stratified excerpts covering front matter, the preface, chapter map, and chapter 1 framing; the detailed content of chapters 2–9 is known only through the table of contents and chapter summaries, so specific code examples and exercises are not described here.