Bjarne Stroustrup - The C++ Programming Language 4th Edition - 2013 (Bjarne Stroustrup)（Z-Library）

【One-Line Pitch】 A guided tour of C++11 by the language's creator, showing how to write code that is simultaneously efficient and elegant. Best for programmers who already know the basics and want to understand *why* C++ is designed the way it is, not just *how* to use it. 【Book Arc】 - **Opening (~0%–10%)**: Frames C++'s dual design goal — direct hardware mapping plus affordable abstraction — and introduces the book's philosophy of expressing ideas directly in code. Establishes that libraries, not bare language features, make real programming pleasant. - **Early (~10%–32%)**: Builds the core toolkit through a worked `Vector` example: classes, error handling via exceptions, templates, and the standard-library container/algorithm model (iterators, sequences, `sort`/`unique_copy`). Moves into fundamental types, pointers, arrays, and references, including rvalue references and move semantics. - **Middle (~39%–48%)**: Covers statements, expressions, and `constexpr` compile-time computation, then functions — argument passing, return values, and the dangers of returning references to locals. Emphasizes symbolic constants over magic numbers and consistent style. - **Late (beyond ~48%)**: Excerpts do not cover the later chapters in detail; based on the book's structure, this is where classes, inheritance, templates, the standard library, and concurrency would be treated in depth. 【Key Takeaways】 - **C++ exists to serve two masters** (Opening): a language close to the machine for efficiency, and close to the problem for abstraction. The whole design — `const`, classes, constructors/destructors, exceptions, templates — flows from reconciling these. - **Abstraction should cost nothing extra** (Opening): user-defined types are meant to match built-in types in notation, range of use, and performance. This is the yardstick for judging any C++ feature. - **Exceptions separate detection from handling** (Early): a `Vector` writer can't know what the user wants on out-of-range access, and the user can't reliably detect it — so the implementer throws and the caller catches. This modularity is why error-handling standards matter as programs and libraries grow. - **Prefer `vector` as your default sequence** (Early): the standard containers share a uniform interface (`size()`, `begin()`, `end()`), which lets algorithms work independently of container type. `vector` is usually more efficient than `list` even for insert/erase on short sequences — you need a reason to choose otherwise. - **Iterators and tag dispatch enable compile-time algorithm selection** (Early): sequences are pairs of iterators, and techniques like `iterator_traits` and tag dispatch pick the right algorithm (random-access vs. forward) at compile time — a recurring pattern for flexibility without runtime cost. - **Move semantics avoid needless copies** (Early): rvalue references (`&&`) implement a "destructive read," turning expensive copies (e.g., in `swap`) into cheap moves. A `const` lvalue reference prevents modification; an rvalue reference enables optimization. - **`constexpr` moves computation to compile time** (Middle): integer square roots and similar work can be done at compile time, and `?:`, `&&`, `||` short-circuit so unevaluated branches need not be constant expressions. This is far safer than macro-based tricks. - **Name your constants; avoid magic numbers** (Middle): repeated literals are a maintenance hazard because every occurrence must change together. Symbolic constants localize assumptions and make porting and revision safer. 【Reading Tips】 - **Deep-read the `Vector` thread** (early chapters): it recurs through classes, exceptions, and templates, and is the book's spine for understanding design trade-offs. - **Skim the reference-style chapters** on fundamental types and expressions if you already know C++; slow down on rvalue references, move semantics, and `constexpr`, which are the C++11-era shifts. - **Treat the "Advice" lists at chapter ends as checklists** — they distill hard-won style rules (prefer range-`for`, avoid `goto`, keep comments crisp) worth revisiting after you write real code. - **Read with a compiler open**: the book is example-driven, and the design rationale only clicks when you try the code and see the trade-offs. 【Coverage Limits】 This guide is based on stratified excerpts covering roughly the first half of the book; later chapters on classes, inheritance, templates, the standard library, and concurrency are not represented, so their treatment here is inferred from the book's known structure rather than the excerpts.