C++Primer Plus 第6版·英文版 下册 (（美）Stephen Prata著, (美)Stephen Prata著, 普拉塔 etc.) (Z-Library)

【One-Line Pitch】 The second half of Stephen Prata's classic C++ tutorial takes you from object-oriented inheritance into the modern standard library and C++11 features, making it the natural next step for readers who already know basic C++ syntax and want to write idiomatic, reusable code. 【Book Arc】 - **Opening (~0%–5%)**: Picks up mid-stream with inheritance fundamentals — base classes, the is-a relationship, polymorphic public inheritance, and the static-versus-dynamic binding distinction that makes virtual functions work. - **Early (~5%–15%)**: Deepens inheritance with access control (protected), abstract base classes, and the tricky interaction between inheritance and dynamic memory allocation, closing with a class design review. - **Middle (~15%–30%)**: Shifts to code reuse beyond inheritance — classes with object members, private and multiple inheritance, and class templates as the foundation for generic programming. - **Late (~30%–55%)**: Covers friends, nested classes, exceptions, runtime type identification, and type cast operators, then moves into the string class, smart pointers, and the Standard Template Library. - **Ending (~55%–100%)**: Finishes with generic programming, function objects, algorithms, stream and file I/O, and a tour of C++11 additions including move semantics, rvalue references, new class features, lambda functions, and wrappers. 【Key Takeaways】 - **Inheritance is about relationships, not just reuse** (Opening): the is-a test and polymorphic public inheritance determine when derivation is appropriate, while static vs. dynamic binding explains why virtual functions matter. - **Abstract base classes define interfaces** (Early): pure virtual functions let you specify a contract without committing to an implementation, a pattern that recurs throughout the STL. - **Reuse has many forms** (Middle): containment, private inheritance, multiple inheritance, and templates each solve different problems; choosing well matters more than picking a favorite. - **Exceptions and RTTI are safety nets** (Late): try/catch/throw and runtime type identification give you controlled ways to handle failure and inspect types at runtime. - **The STL is the payoff of generic programming** (Late): containers, iterators, algorithms, and function objects combine into a reusable toolkit that reshapes how you write everyday C++. - **Smart pointers change resource management** (Late): template-based smart pointer classes reduce the burden of manual memory handling and preview the ownership thinking behind modern C++. - **I/O is a layered system** (Ending): cout, cin, file streams, and in-core formatting share a common design you can extend and reason about. - **C++11 is not a footnote** (Ending): move semantics, rvalue references, lambdas, and wrappers mark a genuine shift in how the language is written, not just added syntax. 【Reading Tips】 - If you already know basic classes and functions, start at the inheritance chapters and read them closely — the static/dynamic binding discussion is the conceptual hinge for everything that follows. - Treat the STL chapters as the book's center of gravity; work the programming exercises rather than reading passively, since container/iterator/algorithm fluency only comes from use. - Skim the class design review and summary sections on a first pass, then return to them after finishing the STL chapters, when the design trade-offs will make more sense. - For the C++11 chapter, read move semantics and rvalue references slowly — they are the hardest material here and reward a second pass. - Keep a compiler open; this is a tutorial, not a reference, and the examples are meant to be typed and modified. 【Coverage Limits】 This guide is based on the table of contents and position markers of the second volume only; the excerpts do not cover the actual prose, examples, or exercises, so specific code details and chapter-level arguments are not summarized here.