Essential C++ (Stanley B. Lippman) (z-library.sk, 1lib.sk, z-lib.sk)

【One-Line Pitch】 A deliberately short, fast-track C++ tutorial for working programmers who need to become productive quickly, teaching the language through progressively harder problems rather than exhaustive reference coverage. Best for developers with some programming experience who want the essentials of procedural, generic, object-based, and object-oriented C++ without wading through a 1,200-page primer. 【Book Arc】 - **Opening (~0%–10%)**: Frames the book's purpose — a compact, just-in-time alternative to the author's much larger *C++ Primer* — and lays out the seven-chapter, two-appendix structure built around increasingly complex programming problems. - **Early (~10%–32%)**: Establishes the language basics in the context of a small interactive program: built-in types, operators, the `vector` and `string` library classes, conditionals and loops, and iostream I/O. The table of contents then moves into functions (inline, overloaded, template, pointers to functions) and the STL — containers, iterators, and generic algorithms. - **Middle (~39%–52%)**: The author's preface explains the book's origin story (a Perl-learning analogy from his animation-studio work) and why a slim volume serves learners better than a comprehensive one. The structural walkthrough then previews class design and object-oriented hierarchies as the book's destination. - **Late (~52% onward)**: Class-based programming (constructors, destructors, `const`/`mutable`, `this`, static members, copy assignment, function objects) and object-oriented programming (abstract base classes, derived classes, virtual functions, RTTI), followed by class templates and exception handling. - **Ending (appendix material)**: Appendix A gives full solutions and explanations to every chapter exercise; Appendix B is an alphabetical handbook of common generic algorithms with a usage example for each. 【Key Takeaways】 - **Brevity is the design goal, not a compromise** (Middle): The author explicitly positions the book against his own 1,200+ page *C++ Primer*, arguing that learners on deadline need the right book, not the best or most complete one. This shapes every chapter's scope. - **Problems drive the language features** (Opening): Rather than cataloging syntax, the book introduces features as solutions to increasingly complex programming problems, so readers learn purpose and rationale alongside mechanics. - **Four programming styles are covered in sequence** (Early–Late): Procedural, generic, object-based, and object-oriented programming each get dedicated treatment, giving a coherent progression from fundamentals to advanced design. - **Library classes are taught before raw C constructs** (Early): The author deliberately introduces `vector` and `string` early and encourages their use over built-in arrays and C-style strings — a modern-usage stance worth adopting from day one. - **The STL is treated as core, not optional** (Early): Containers (`vector`, `list`, `set`, `map`), iterators, and generic algorithms (`sort()`, `copy()`, `merge()`) form a full chapter, with a companion algorithm reference in Appendix B. - **Class design is the book's center of gravity** (Late): Constructors, destructors, `const`/`mutable`, `this`, static members, copy assignment, friendship, and function objects are covered as the primary activity of a C++ programmer. - **Inheritance and dynamic binding complete the arc** (Late): Abstract base classes, derived classes, virtual functions, and RTTI are presented as the way to model families of related types instead of duplicating independent classes. - **Exercises come with full worked solutions** (Ending): Appendix A's detailed answers reinforce learning at the reader's own pace — a rare and practical feature for self-study. 【Reading Tips】 - **Skim the front matter once, then start at Chapter 1**: The preface and structure notes are motivational and organizational; the real value begins with the interactive-program chapter. - **Deep-read Chapters 4–5 if your goal is design work**: Class implementation and object-oriented hierarchies are where the book's density and payoff are highest; the early chapters can be read faster if you already know another language. - **Work the exercises with Appendix A nearby**: The solutions are explanatory, not just answers — use them to check your reasoning, not merely your output. - **Keep Appendix B as a desk reference**: The generic-algorithms handbook is built for lookup during real coding, not linear reading. - **Watch for the case study thread**: The blurb notes a recurring case study that ties chapters together; tracking it makes the progression from procedural to object-oriented feel continuous. 【Coverage Limits】 The excerpts are dominated by front matter, table of contents, and appendix listings; they do not cover the actual body prose, code examples, or the case study's content, so this guide describes the book's structure and stated intent rather than its detailed lessons.