Beautiful C++ 30 Core Guidelines for Writing Clean, Safe, and Fast Code (Kate Gregory J. Guy Davidson)（Z-Library）

# Beautiful C++: 30 Core Guidelines for Writing Clean, Safe, and Fast Code ## 【One-Line Pitch】 A practical, developer-focused tour of the C++ Core Guidelines, distilling 30 high-impact rules into actionable advice for writing cleaner, safer, and faster C++ code. Ideal for working C++ programmers—from veterans to recent converts—who want to modernize their style without drowning in the full Guidelines document. ## 【Book Arc】 - **Opening (~0%–15%)**: Introduces the Core Guidelines project and the book's philosophy—avoiding "bikeshedding" (wasting time on trivia) and focusing on rules that deliver real benefits. Sets up the book's structure, which mirrors the official Guidelines website for easy cross-referencing. - **Early (~15%–35%)**: Covers foundational style rules: writing ISO Standard C++, preferring default arguments over overloading, using in-class member initializers, avoiding trivial getters/setters, declaring one name per declaration, and not insisting on single return statements. These are quick wins for code clarity. - **Middle (~35%–65%)**: Addresses "don't hurt yourself" rules—encapsulating messy constructs, keeping function arguments low, using C-style subsets for cross-compiler ABIs, initializing members in declaration order, minimizing shared writable data, and using template metaprogramming sparingly. Also begins the "stop using that" section on legacy pitfalls. - **Late (~65%–90%)**: Continues with rules to abandon: raw pointer ownership transfer, singletons, memset/memcpy for object initialization, casting away const, error handling via global state (errno), and `using namespace` at global scope in headers. Then shifts to "use this new thing properly"—returning structs/tuples for multiple outputs, class enums, small scopes, constexpr, templates for abstraction, and concepts. - **Ending (~90%–100%)**: Concludes with "write code well by default"—statically type-safe programs, immutable data, encapsulating rule violations, declaring variables only when you have values, designing for optimization, and using RAII to prevent leaks. Ends with an envoi and afterword. ## 【Key Takeaways】 - **Bikeshedding is a real productivity killer** (Early): The book's core premise is that many C++ debates (naming, formatting) waste time; the Guidelines help you focus on rules that materially improve code quality and maintainability. - **Prefer modern initialization over constructors that only set members** (Early): In-class member initializers are simpler, less error-prone, and avoid duplication—a small change with outsized clarity benefits. - **Encapsulate messiness rather than spreading it** (Middle): When you must do something ugly (platform-specific code, tricky logic), isolate it in one place so the rest of your codebase stays clean and reviewable. - **Raw pointers should never transfer ownership** (Late): This is a foundational safety rule—use smart pointers or containers instead, and you eliminate a whole class of leaks and dangling-pointer bugs. - **Avoid singletons and global state for errors** (Late): Both create hidden dependencies and make testing/evolution harder; prefer explicit dependency injection and exception-based or return-value error handling. - **Use new features deliberately, not just because they're new** (Late): Class enums, constexpr, templates, and concepts are powerful—but the book emphasizes using them *properly* to get benefits without introducing new problems. - **Design for static type safety and immutability by default** (Ending): Preferring immutable data and type-safe interfaces makes code easier to reason about, optimize, and evolve—quality becomes the default, not an afterthought. - **RAII is your best friend for resource management** (Ending): The book reinforces that RAII (Resource Acquisition Is Initialization) prevents leaks by tying resource lifetime to object scope—a timeless C++ principle. ## 【Reading Tips】 - **Skim the Opening and Early sections** if you're already experienced with modern C++—the style rules (default arguments, member initializers, single declarations) are quick wins but may feel basic. - **Deep-read the Middle and Late sections** ("Don't hurt yourself" and "Stop using that")—these contain the most actionable, high-impact advice for cleaning up legacy code and avoiding common pitfalls. - **Pay special attention to the "Use this new thing properly" section** (Late): This is where the book shines, showing how to adopt C++11/14/17/20 features correctly rather than superficially. - **Use the book as a companion to the official Guidelines website**: The structure aligns with the online document, so you can cross-reference for deeper dives or related rules. - **Focus on the "why" behind each rule**: The authors emphasize benefits and nightmares (what happens if you ignore the rule), which makes the advice stick better than rote memorization. ## 【Coverage Limits】 The excerpts primarily cover the table of contents and introductory material; detailed code examples and in-depth explanations for each guideline are not fully visible in the source material. This guide synthesizes the book's structure and apparent themes based on the available content. ##