C++17 STL Cookbook Over 90 recipes that leverage the powerful features of the standard library in C++17 (Jacek Galowicz)（Z-Library）

# C++17 STL Cookbook — Reading Guide ## 【One-Line Pitch】 A practical, recipe-driven tour of C++17's Standard Library that shows you how to solve real-world problems with modern, elegant, and portable code — ideal for intermediate C++ developers who want to move beyond the basics and write idiomatic STL-style programs. ## 【Book Arc】 - **Opening (~0%–9%)**: Introduces the new C++17 core language features — `if`/`switch` with initializers, `constexpr-if`, and fold expressions — explaining the problems they solve (scope pollution, compile-time branching, variadic template expansion) and why they make metaprogramming more readable. - **Early (~16%–28%)**: Dives into STL containers — `std::vector`, `std::map`, `std::set`, `std::stack` — with recipes for keeping vectors sorted, handling out-of-bounds access safely, using insertion hints for performance, and building a reverse Polish notation calculator and sentence-length statistics tool. - **Early-to-Middle (~28%–38%)**: Explores iterators in depth — input/output iterators, reverse iterators, and `std::istream_iterator` — plus how to build custom iterator adapters like a "zip" iterator, with a strong emphasis on using sanitizers for bug detection. - **Middle (~38%–47%)**: Focuses on lambda expressions and functional programming style — capturing variables, composing functions with `std::function`, building multicall helpers, and generating cartesian products at compile time using parameter packs and lambdas. - **Late (~47%–end)**: Continues with advanced STL usage — algorithm composition, performance optimization, and practical patterns for combining the library's building blocks into clean, maintainable solutions (excerpts thin here; later chapters likely cover strings, concurrency, and filesystem). ## 【Key Takeaways】 - **C++17 language features reduce boilerplate and scope pollution** (Early): `if`/`switch` initializers keep variables scoped to the branch where they're used, making code tidier and easier to refactor — no more extra braces or leaked variables. - **`constexpr-if` revolutionizes template metaprogramming** (Early): Compile-time branching with `if constexpr` lets you write type-dependent code that reads like normal control flow, eliminating the need for complex SFINAE or tag dispatch in many cases. - **Fold expressions simplify variadic template operations** (Early): A single expression like `(std::count(std::begin(range), std::end(range), ts) + ...)` can replace pages of recursive template code — powerful for building concise, readable helpers. - **Containers have hidden performance tricks** (Early): `std::map` insertion hints can give amortized O(1) insertion when keys are neighbors, and keeping a `std::vector` sorted manually is often simpler than switching to a tree-based structure. - **Iterators are the backbone of STL algorithms** (Early): Understanding iterator categories (input, output, bidirectional, etc.) is essential — and `std::make_reverse_iterator` lets you reuse normal algorithms on reversed ranges with minimal effort. - **Lambdas enable powerful function composition** (Middle): Combining lambdas with `std::function` and parameter packs lets you build composable, Lego-brick-style utilities (like `multicall` or `transform_if`) that compile to efficient code with zero runtime overhead. - **Sanitizers are a professional necessity** (Middle): The author strongly advocates for regular testing with sanitizers — a practical habit that catches sneaky bugs and is often missing in real-world teams. ## 【Reading Tips】 - **Skim the opening language-feature chapters** (~0%–9%) if you're already familiar with C++17 basics — but do read the `constexpr-if` and fold-expression recipes carefully, as they're used throughout the rest of the book. - **Deep-read the container chapters** (~16%–28%): The recipes here (sorted vectors, insertion hints, RPN calculator) are the most transferable to daily work — pay attention to the "How it works" sections that explain the underlying data structures. - **Treat the iterator chapter** (~28%–38%) as essential foundation: The custom zip iterator recipe is challenging but worth the effort — it teaches you how iterators really work under the hood. - **Don't skip the lambda composition recipes** (~38%–47%): Even if you think you know lambdas, the multicall and cartesian-product examples show advanced patterns you won't find in most tutorials. - **Keep a compiler handy**: This is a hands-on cookbook — the recipes are meant to be typed, compiled, and experimented with, not just read. ## 【Coverage Limits】 This guide covers the first ~47% of the book in detail (language features, containers, iterators, lambdas). The later chapters on strings, algorithms, concurrency, and the filesystem library are not covered in the available excerpts. ##