C++ Standard Library Quick Reference (Peter Van Weert, Marc Gregoire (auth.))（Z-Library）

【One-Line Pitch】 A compact, practice-driven field guide to the C++14 and C11 standard libraries that turns a sprawling specification into something you can actually navigate. Best for working C++ programmers who want fast, accurate answers and a memory aid—not a from-scratch language tutorial. 【Book Arc】 - **Opening (~0%–10%)**: Orients you with the book's philosophy and scope—a deliberately terse summary of the C++14/C11 libraries, explicitly skipping obscure features and bloated examples in favor of practical, bullet-style coverage. - **Early (~10%–32%)**: Builds the numeric and math foundation: `<cmath>`, `<limits>` type properties, fixed-width integer typedefs, `<complex>`, random-number engines and distributions, and `<valarray>` slicing with `slice`/`gslice`. - **Early–Middle (~32%–48%)**: Moves into general utilities—move/forward/swap, pairs and tuples, smart pointers (`unique_ptr`, `shared_ptr`, `weak_ptr`), function objects and `bind`, initializer lists, and the `<chrono>` date/time facilities. - **Middle (~48%–60%)**: Covers characters and strings, including searching and modifying strings and pattern matching via regular expressions. - **Late**: Containers, algorithms, and lambda expressions—the STL core the introduction flags as the usual focus of competing references. - **Ending**: Stream and file I/O, localization, concurrency, and exception handling, closing the loop on the "write safe, efficient multithreaded code" promise. 【Key Takeaways】 - **The book is a summary by design, not a tutorial** (Opening): it assumes basic C++ knowledge and optimizes for lookup speed over exhaustive explanation. - **Numeric type introspection is a first-class tool** (Early): `<limits>` and the fixed-width typedefs let you query type properties portably instead of hardcoding assumptions. - **Prefer the predefined random engines** (Early): the library ships expert-tuned engines like `mt19937` so you don't hand-roll parameters. - **Smart pointers are framed around ownership semantics** (Middle): `unique_ptr` for exclusive transfer, `shared_ptr`/`weak_ptr` for shared and non-owning references, with `make_unique()` recommended to avoid leak-prone construction. - **`<chrono>` separates durations, time points, and clocks** (Middle): understanding which clock is steady matters for correct timing code. - **Functors and lambdas are the glue for algorithms** (Middle): `<functional>` facilities plus lambda expressions enable elegant, reusable callbacks. - **Concurrency and exceptions are treated as practical safety concerns** (Late): the library's threading and error-handling tools are presented as everyday correctness tools. 【Reading Tips】 - Use it as a **reference, not a cover-to-cover read**—jump to the header you need via the table of contents. - **Deep-read the smart-pointer and `<chrono>` sections**; these are where subtle bugs (leaks, non-steady clocks) hide. - **Skim the numeric/`<valarray>` material** unless you do matrix or scientific work; it's the most specialized part. - Watch the **tips and short examples**—they encode the practical "watch out for" knowledge the authors promise. - Keep it beside you while coding to reinforce API recall; the compact style rewards repeated dipping. 【Coverage Limits】 This guide is synthesized from stratified excerpts covering roughly the opening through the middle of the book; the later chapters on containers, algorithms, I/O, localization, concurrency, and exceptions are referenced from the introduction and table of contents but their detailed content is not covered by the excerpts.