C++23 Best Practices (Jason Turner) (Z-Library)

【One-Line Pitch】 A practical, opinionated field guide to writing modern C++ that is safe, fast, and maintainable, updated for C++20/23 features like modules, concepts, ranges, and `std::format`. Best suited to working C++ developers who already know the language and want a checklist of habits that prevent real-world bugs and performance traps. 【Book Arc】 - **Opening (~0%–10%)**: Frames the book's philosophy — C++ is not magic, and you can reason about every behavior. Introduces the exercise-driven format, the use of `struct` in examples, and the idea that best practices must be applied with judgment rather than dogma. - **Early (~10%–35%)**: Shifts to tooling as the foundation of quality: compiler warnings, static analysis, sanitizers, fuzzing, mutation testing, build generators, and package managers. The message is that discipline is enforced by automation, not willpower. - **Middle (~35%–55%)**: Moves into API and type design — avoiding undefined behavior at API boundaries, using stronger types, `[[nodiscard]]`, modules over headers, stack over heap, and not returning raw pointers. This is where interface safety and ownership clarity take center stage. - **Late (~55%–75%)**: Covers modern language mechanics: concepts instead of SFINAE, `consteval`/`constinit`, the spaceship operator, and the Rule of 0/5 for resource management. The focus is on letting the compiler do more work for you. - **Ending (~75%–100%)**: Code implementation guidelines — `std::format` over iostreams, `constexpr` everywhere, `const` correctness, initialization discipline, `auto` usage, ranges and views, and algorithms over hand-written loops. The excerpts do not cover the final chapters in detail. 【Key Takeaways】 - **Tooling is not optional** (Early): Warnings, sanitizers, static analysis, and fuzzing catch classes of bugs that code review cannot. The book treats them as baseline infrastructure, not extras. - **Undefined behavior is a design concern, not just a runtime one** (Early–Middle): APIs that accept raw pointers or unchecked values invite UB. Prefer `not_null`, `std::span`, and `std::string_view` to make invalid states unrepresentable. - **Stronger types prevent real bugs** (Middle): Replacing `Rectangle(int, int, int, int)` with `Rectangle(Position, Size)` eliminates a whole category of argument-order mistakes. `=delete` can block dangerous implicit conversions. - **Stack over heap, value over pointer** (Middle): Stack objects are optimizer- and cache-friendly. Returning raw pointers forces callers to guess ownership; prefer references, smart pointers, or values. - **Concepts replace SFINAE for clearer templates** (Late): They improve error messages, compile times, and readability. The book shows rewriting `if constexpr`-based dispatch as concept-constrained overloads. - **Rule of 0 first, Rule of 5 only when necessary** (Late): Empty destructors harm performance and disable moves. Manual resource management should be rare and, when required, follow the full Rule of 5. - **`constexpr` and `const` are default habits** (Ending): Globals in headers should be `inline constexpr`; everything not `constexpr` should be `const` where possible. This shifts work to compile time and prevents accidental mutation. - **Ranges, views, and algorithms beat manual loops** (Ending): They improve correctness and readability, but views should not be reused — a subtle trap the book calls out explicitly. 【Reading Tips】 - **Deep-read the tooling chapters (Early)** even if you think your setup is fine. The warning-flag and sanitizer advice is concrete and immediately actionable. - **Skim the API design chapters if you are not writing library code**, but read the sections on `[[nodiscard]]`, stronger types, and `=delete` — they apply to application code too. - **Treat the exercises as the real content.** The book is structured around them; doing them against your own codebase is where the value lands. - **Watch for C++23-specific guidance** on modules and `std::format`; these are the areas where the book deliberately breaks from older editions. - **Do not read cover-to-cover in one pass.** The items are largely independent; use the table of contents as a checklist and revisit items relevant to your current work. 【Coverage Limits】 This guide is based on stratified excerpts covering roughly the first half of the book plus the table of contents. Later chapters on ranges, views, algorithms, and ranged-for loops are only partially represented, and the excerpts do not cover the book's treatment of concurrency, error handling, or testing frameworks in depth.