We earn a commission if you buy through these links. Learn more
Effective C++
by Scott Meyers
Numbered guidelines distilled from years of C++ practice, showing how to avoid the subtle design and resource bugs that trip up working programmers.
What It's About
Effective C++ is a compact, dense book of numbered guidelines. Each item is a rule of thumb with an explanation of why it exists and what goes wrong when you ignore it. Meyers wrote it for working programmers who already know the language's syntax but are unsure how to design classes, manage resources, and avoid subtle bugs. Rather than teaching C++ from the ground up, it assumes you can write the language and focuses on the habits that separate code that compiles from code that holds up.
Each item stands on its own, so you can open to any page and get something useful in a few minutes. The examples are small and pointed, usually a short snippet showing a tempting but flawed approach followed by a better one. Meyers explains the reasoning rather than just issuing commands, and the tone is brisk and opinionated, naming common mistakes before correcting them.
The reading experience is closer to a series of focused lessons than a continuous narrative. Expect to return to items when you run into their situations in real code. The book is most rewarding after you have written a good amount of C++ yourself, when the advice starts matching problems you have already hit.
Read this if you…
- are writing C++ daily and want fewer subtle bugs in your classes
- want a compact collection of hard-won design habits you can reread
- are moving to C++ from C or another language and need the idioms that matter
Skip it if you…
- are new to C++ and still learning basic syntax; start with an introductory text
- need coverage of modern C++ features such as move semantics and lambdas, which postdate this edition
Key Ideas
- 1
Prefer the compiler to the preprocessor
Meyers argues that the preprocessor's textual substitution hides errors, since a macro never gets type checked and its name may vanish before the debugger sees it. Replacing simple macros with named constants, enumerations, or inline functions gives the compiler more information to catch mistakes and leaves you symbols you can actually inspect. The advice is simple to state but changes how you think about every header you write.
- 2
Manage resources with objects
Resource leaks are among the most common C++ bugs, especially when an exception interrupts a function between acquiring and releasing something. The book's recurring answer is to wrap raw resources such as heap memory, file handles, and locks in objects whose destructors perform the cleanup. Once you see this pattern, you will recognize it in standard library classes and in your own designs.
- 3
Design classes around their special member functions
Compilers quietly generate copying, assignment, and destruction behavior for classes, and those defaults often do the wrong thing for classes that own resources. Meyers shows how to decide which functions to define, disable, or accept. He also explains why a base class used polymorphically usually needs a virtual destructor, a point that is easy to miss and expensive to get wrong.
- 4
Use inheritance and templates deliberately
Inheritance and templates are powerful and easy to misuse. The book treats public inheritance as a statement that a derived class is a kind of its base, and it cautions against overusing inheritance when composition would express the same relationship more clearly. The template-related items introduce generic programming ideas, with advice on keeping template code correct and maintainable.
Limitations
The main criticism is age. This edition, from 2005, predates C++11 and later standards, so move semantics, lambdas, and many modern idioms are missing or only hinted at. Some readers find the items unevenly weighted, and the prescriptive tone can feel rigid when the trade-offs are genuinely close. The book also does not teach the standard library in depth or cover large-system design, testing, or tooling. Meyers' later Effective Modern C++ addresses newer standards and is a natural companion.
Questions Readers Ask
- Is Effective C++ still worth reading when it predates C++11?
- Yes, for the design principles, which change slowly. Resource management, class design, and avoiding subtle bugs remain relevant. For newer language features, pair it with Meyers' Effective Modern C++, which covers C++11 and C++14 in the same item-based style.
- How does it compare to The C++ Programming Language?
- Stroustrup's book is a comprehensive language reference and tutorial written by the language's creator. Effective C++ is narrower: a set of targeted guidelines for avoiding common mistakes. Many readers use both, with the reference for breadth and Meyers' book for practical judgment.
- Can I read Effective C++ without knowing C++ well?
- Not comfortably. The book assumes you already know the syntax and basic semantics of the language. If you are still learning classes, pointers, and templates, work through an introductory text first, then return to these items when you start writing real programs.
- Published
- 1991
- ISBN
- 9780201924886
- Difficulty
- intermediate
- Category
- Tech
Book details and cover from Google Books.
Ready to read Effective C++?
Get your copy on Amazon, or listen to it on Audible. We earn a commission if you buy through these links.