Beautiful C++: 30 Practical Rules for Better Code

Introduction

The book "Beautiful C++: 30 Core Guidelines for Writing Clean, Safe, and Fast Code" was published in 2021 by Addison-Wesley. The authors are J. Guy Davidson and Kate Gregory — renowned experts in the C++ community, members of the standardization committee, and authors of numerous technical articles. Unlike academic textbooks, this book does not teach the language from scratch but offers a meaningful set of practical recommendations based on the C++ Core Guidelines (recommendations by Bjarne Stroustrup and Herb Sutter).

What the book is about

The book consists of 30 chapters, each dedicated to one guideline. The guidelines are grouped by thematic sections: safety, expressiveness, performance, memory management, interface design, etc. The authors do not simply list dry directives — they explain in detail why a rule is important, show typical mistakes (antipatterns), and offer correct alternatives in C++17 and C++20. Each chapter ends with a summary and a list of references for further study.

Who this book is for

The book is aimed at practicing C++ developers who already have coding experience (at least 1–2 years) and want to improve its quality. It will be useful for:

• Developers transitioning from C++11/14 to C++17/20;
• Participants in code reviews looking for objective evaluation criteria;
• Team leads and architects shaping coding standards within a team;
• Senior students studying industrial programming.

What the reader will learn

After reading, the reader will be able to:

• Write safe code — avoid undefined behavior, memory leaks, data races;
• Use RAII (Resource Acquisition Is Initialization) for automatic resource management;
• Apply smart pointers (unique_ptr, shared_ptr, weak_ptr) instead of raw new/delete;
• Design expressive interfaces — use const, noexcept, explicit, concepts (C++20);
• Optimize performance without sacrificing readability — choose containers, algorithms, avoid copying;
• Work with exceptions wisely: not overuse them, but not avoid them where appropriate;
• Use modern features of C++17/20: structured bindings, if constexpr, std::optional, std::variant, ranges;
• Conduct code reviews based on objective criteria rather than personal preferences.

Strengths

1. Practical focus. Each rule is accompanied by real code examples (often fragments from open-source projects). The authors show how "bad" code is transformed into "beautiful" code step by step.

2. Relevance. The book is oriented toward C++17 and C++20 — the latest standards at the time of publication. Concepts, ranges, and coroutines are covered (in the context of the rules).

3. Authority. Both authors are members of the ISO C++ committee and directly participate in the development of the Core Guidelines. The book is not just a retelling but a thoughtful selection with insider commentary.

4. Structure. 30 rules is an optimal number for sequential study. The book can be read either in its entirety or selectively, referring to the relevant chapter as needed.

5. Language. Written in a lively, accessible style, without excessive academicism. Even complex topics (move semantics, perfect forwarding) are explained at an intuitive level.

Who it is recommended for

The book will be useful for anyone who writes in C++ and wants to do it better. I especially recommend it to teams that are implementing or planning to implement