Effective Modern C++ 42 Specific Ways to Improve Your Use of C++11 and C++14 (Scott Meyers)（Z-Library）

【One-Line Pitch】 A practical, item-based guide to writing correct, efficient, and maintainable code with C++11 and C++14, ideal for experienced C++ developers transitioning from C++98 or seeking to master modern idioms like move semantics, type deduction, and smart pointers. 【Book Arc】 - **Opening (~0%–9%)**: Introduces the book's scope and terminology (e.g., raw vs. smart pointers, signatures, undefined behavior), then dives into template type deduction rules, distinguishing cases for references, universal references, and by-value parameters. - **Early (~9%–25%)**: Explores `auto` and `decltype` type deduction, including pitfalls like braced initializers and how to use `decltype(auto)` for perfect forwarding in function templates. - **Early (~25%–34%)**: Covers variable declaration best practices—preferring `auto` over explicit types, avoiding `std::function` for closures (due to heap allocation), and understanding proxy classes like `std::vector<bool>::reference`. - **Middle (~34%–47%)**: Discusses initialization syntax (braces vs. parentheses), the most vexing parse, and `std::initializer_list` overload traps; then shifts to null pointer best practices (`nullptr` over `0`/`NULL`) and scoped enums (`enum class`) for type safety. - **Late (~47%–end)**: Continues with advanced topics like `noexcept`, smart pointer `make` functions, and universal references, though excerpts thin out; the book closes with practical guidance on applying these idioms consistently. 【Key Takeaways】 - **Template type deduction has three cases** (Early): reference/pointer (non-universal), universal reference, and by-value; each has distinct rules (e.g., references are ignored, const is dropped for by-value). This is foundational for writing generic code. - **`auto` type deduction differs from template deduction** (Early): `auto` treats braced initializers as `std::initializer_list`, while templates don't; C++14 `auto` return types and lambda params use template rules. This prevents subtle bugs in initialization. - **`decltype` gives exact types, enabling `decltype(auto)`** (Early): Use it for perfect-forwarding function returns, like `authAndAccess`, to preserve references and constness; C++11 requires trailing return types. - **Prefer `auto` over explicit types for variables** (Early): It avoids uninitialized variables and type mismatches, but beware proxy classes like `std::vector<bool>::reference` that can dangle; use `static_cast` to materialize values. - **Braced initialization is "uniform" but has traps** (Middle): It prevents narrowing and vexing parse, but can hijack overloads via `std::initializer_list` (e.g., `std::vector<int>{10, 20}` creates 2 elements, not 10). Design constructors to avoid surprises. - **Use `nullptr` instead of `0` or `NULL`** (Middle): In templates, `0` and `NULL` deduce as integral types, causing type errors; `nullptr` converts cleanly to any pointer type, avoiding overload ambiguity. - **Prefer scoped enums (`enum class`)** (Middle): They prevent namespace pollution and implicit conversions to integral/floating types, catching errors like comparing a color to a double; use `std::underlying_type` for generic access. 【Reading Tips】 - **Deep-read Items 1–4** (type deduction) and Item 7 (initialization) carefully—they underpin most modern C++ pitfalls; skim the Boost.TypeIndex example in Item 4 if you're not using Boost. - **Skim the "Things to Remember" summaries** at each item's end for quick reference; they distill the key rules without the detailed rationale. - **Watch for cross-references** (e.g., Item 24 on universal references, Item 25 on `std::forward`); read them in sequence if you're new to move semantics, as they build on each other. - **Practice with the `authAndAccess` example** (Item 3) to solidify `decltype(auto)` and perfect forwarding; it's a canonical pattern for generic container access. - **Take away the "why" behind each rule** (e.g., why `auto` beats `std::function` for closures) to apply these idioms beyond the book's examples. 【Coverage Limits】 Excerpts cover roughly the first half of the book (Items 1–10); later items on smart pointers, `noexcept`, and concurrency are mentioned but not detailed here.