C++ Templates The Complete Guide (David Vandevoorde, Nicolai M. Josuttis etc.) (z-library.sk, 1lib.sk, z-lib.sk)

【One-Line Pitch】 A rigorous, standards-current guide to how C++ templates actually work and how to use them well—written for working C++ programmers who want to move past cargo-cult template code into deliberate, maintainable generic design. 【Book Arc】 - **Opening (~0%–15%)**: A fast tutorial on function templates, class templates, nontype parameters, and variadic templates—enough to get you writing and reading modern template code before the reference material begins. - **Early (~15%–35%)**: Practical fundamentals that trip people up: `typename`, zero initialization, `this->`, member and variable templates, template template parameters, perfect forwarding, `enable_if<>`, and the by-value vs. by-reference decision. - **Early–Middle (~30%–40%)**: Compile-time programming (metaprogramming, `constexpr`, SFINAE, compile-time `if`) plus the practical side—inclusion model, linker errors, precompiled headers, and decoding template error messages. - **Middle (~40%–60%)**: The language-detail reference: parameter/argument taxonomy, pack expansions, friends, name lookup and ADL, parsing dependent names, and the instantiation model (lazy instantiation, two-phase lookup, points of instantiation). - **Late (~60%–85%)**: Deduction in depth—deduced contexts, initializer lists, parameter packs, reference collapsing, forwarding references, and SFINAE—then the idioms and techniques built on top of them. - **Ending (~85%–100%)**: Advanced applications, standard-library utilities for generic programming, and a forward look at concepts; excerpts do not cover the exact closing chapters. 【Book Arc note】The excerpts are dominated by the table of contents and front matter, so the percentage bands above are approximate and inferred from chapter ordering rather than from sampled prose. 【Key Takeaways】 - **Templates are a language, not a shortcut** (Opening): the book treats template behavior—translation phases, instantiation, lookup—as first-class knowledge, because misunderstanding it is the root of most template bugs. - **Modern standards change the rules** (Early): variadic templates, generic lambdas, class template argument deduction, compile-time `if`, forwarding references, and user-defined literals are woven in rather than bolted on, so the guidance reflects C++11/14/17 rather than pre-2011 habits. - **Parameter passing is a design decision** (Early): the by-value / by-reference / forwarding-reference trade-offs and `std::ref`/`std::cref` get a dedicated treatment—useful because this is where generic code silently loses performance or correctness. - **SFINAE and `enable_if<>` are explained as tools, not magic** (Early–Middle): the book connects substitution failure, `decltype`, and compile-time branching, then shows how concepts can simplify the same expressions. - **Instantiation is lazy and two-phase** (Middle): knowing when templates are instantiated and how names are looked up explains linker errors, ODR issues, and why some code compiles only in certain translation units. - **Name lookup and parsing are the hard core** (Middle): dependent names, ADL, `typename`/`.template` disambiguation, and dependent base classes are covered in detail—this is the material most readers need to reread. - **Deduction has edge cases worth mastering** (Late): deduced contexts, initializer lists, pack deduction, reference collapsing, and "deduction surprises" are treated systematically rather than as trivia. - **Practice follows theory** (Late): idioms, advanced applications, and standard-library generic utilities show how the language rules translate into reusable, maintainable code. 【Reading Tips】 - **Read Part I straight through, then treat the rest as reference.** The tutorial chapters are short and build vocabulary; the language-detail chapters are best consulted when a real bug or design question arises. - **Deep-read the chapters on instantiation, name lookup, and deduction.** These are the highest-density, highest-payoff sections and the ones most likely to change how you debug template errors. - **Skim the taxonomy and afternotes on a first pass.** Terminology chapters reward a second visit once you have concrete examples in mind. - **Keep a compiler open.** The book's value is in behavior you can observe; reproduce the small examples rather than reading them passively. - **Use the companion site (tmplbook.com) for sample code and updates**, especially where the text previews features like concepts that may have evolved since publication. 【Coverage Limits】 This guide is based on stratified excerpts that are largely front matter and table-of-contents material; specific chapter contents, examples, and the closing chapters on advanced applications and concepts are only partially represented.