Review: Effective C++

Loyal reader SEGV has written a review of Effective C++, the language we all know and love. A good book for people who have a grasp of the language and looking to deepen their knowledge. Click below to read more.

This also is my first book review for Slashdot, and I also have "reused" Rick Franchuk's review layout. The text, however, is mine: warts and all.

Effective C++: Second Edition

Scott Meyers

(Addison Wesley Longman, Inc. ISBN: 0-201-92488-9)

Nutshell Review Up to date revision of a classic book, highly applicable to real-world software development. Not a language reference or primer, but rather a series of essays on the trickier points of C++, how they can cause you grief, and how you can harness their power. Intermediate level, yet easily read.

Rating 10/10

review by SEGV

I've just finished reading the second edition of Effective C++, subtitled "50 Specific Ways to Improve Your Programs and Designs." I really should have read it a year or two ago, as was wisely recommended to me. In that time I've had to debug (others') code that illustrated several Items in this book, and it truly would have helped me then to fully understand what was going on.

What this->book Isn't, and Is

This book doesn't teach the C++ language. It isn't suitable as a reference, or as an introduction to the language. You are expected to know the basics of C and C++: what a class is, what inheritance does, and so on. Rather, this book aims to teach you how to use the language, effectively. It does so by presenting 50 Items, each of which is a simple guideline with several pages of explanatory text. [Check out Item titles in the table of contents below.]

Meyers supports each guideline with illustrative examples and lucid code. He clearly describes what is going on, where you (or others) might get tripped up, and why that is so. Practical man that he is, he even provides you with the safest way to bend the guidelines, for those rare times when you must. And he does all of this in a humourous style!

A Prayer Book for Developers

The Items don't state "Thou shall" or "Thou shalt not." All the same, this book can be read like a Bible. Perhaps read an item per sitting. Or skip to one that interests you (or is relevant to what you are currently coding). Submit an Item to serious study. Memorize the Items' prescriptions, philosophize over their inner meaning. And punish yourself if you sin.

Really, before a developer starts writing his own operator new he will want to read the Items on memory management in C++. There are a few gotchas there. In fact, read those Items before you even call new!

If you don't, you will surely end up in programmer's hell.

Standard C++

This book pretty much covers Standard C++, having been recently revised. In many cases Meyers shows why the new language features are superior to the old way (either C or pre-standard C++). Still, he is careful to show alternative implementations in areas where compilers are not yet up to spec. Although he provides an overview of the standard library and encourages its use everywhere, you'll need another reference to learn it. But you knew that already.

Anecdotal Evidence

I don't fondly remember the few days I spent debugging a particular memory related crash. In the end I discovered that the author of a "smart" pointer class had failed to provide a copy constructor. As it happened, his compiler had optimized out some temporary objects, and so did two of mine. But a fourth compiler created temporaries, and without the copy constructor a reference count was off. As the object was passed back up the call chain as return values, it was deleted out from under itself. Nasty.

Meyers brings up all these issues, and explains them better than I, in Items 11, 27, and 45. Following his guidelines, a copy constructor would have been written either as a matter of course, or made unavailable to users of the class. This bug could have been prevented.

I now keep a printout of the Item titles on the wall by my desk.

Recommendation: Learn it, Love it, Live it

Buy this book and take it to heart. Your co-developers will love you for it, or just not kill you, depending on their disposition. I'm assuming you are a developer, but if not, this book is suitable for any intermediate student of the C++ language. Language features are explained as they are used, just not in an exhaustive fashion. Rather, they are brought to bear when the design issue they are applicable to is being discussed.

Keep it handy, right between your introductory C++ book and Bjarne Stroustrup's The C++ Programming Language. You'll use it.

Online Support

The publisher hosts a web page to support the book: http://www.aw.com/cseng/titles/0-201-92488-9/. It contains the full text of the TOC, Preface, and Items 10, 21, 24, and 32. It also contains updates and errata, in case you're unlucky like me and have an earlier (second) printing. [I was hoping to get into the acknowledgements when I found a genuine error, but it has been fixed in the fourth (current) printing. Doh!]

More Effective C++

If you're like me and craving more, Meyers has it covered. I'm currently reading More Effective C++, subtitled "35 New Ways to Improve Your Programs and Designs." Again, the supporting web page at http://www.aw.com/cseng/titles/0-201-63371-X/ has available the full text of several Items, and also an auto_ptr implementation in case you're curious how a "smart" pointer works. A great candidate for another review. :-)

Check this book out over at Amazon.

Table of Contents

Preface

Acknowledgements

Introduction

Shifting from C to C++

Item 1: Prefer const and inline to #define.
Item 2: Prefer to .
Item 3: Prefer new and delete to malloc and free.
Item 4: Prefer C++-style comments.

Memory Management

Item 5: Use the same form in corresponding uses of new and delete.
Item 6: Use delete on pointer members in destructors.
Item 7: Be prepared for out-of-memory conditions.
Item 8: Adhere to convention when writing operator new and operator delete.
Item 9: Avoid hiding the "normal" form of new.
Item 10: Write operator delete if you write operator new.

Constructors, Destructors, and Assignment Operators

Item 11: Declare a copy constructor and an assignment operator for classes with dynamically allocated memory.
Item 12: Prefer initialization to assignment in constructors.
Item 13: List members in an initialization list in the order in which they are declared.
Item 14: Make destructors virtual in base classes.
Item 15: Have operator= return a reference to *this.
Item 16: Assign to all data members in operator=.
Item 17: Check for assignment to self in operator=.

Classes and Functions: Design and Declaration

Item 18: Strive for class interfaces that are complete and minimal.
Item 19: Differentiate among member functions, non-member functions, and friend functions.
Item 20: Avoid data members in the public interface.
Item 21: Use const whenever possible.
Item 22: Prefer pass-by-reference to pass-by-value.
Item 23: Don't try to return a reference when you must return an object.
Item 24: Choose carefully between function overloading and parameter defaulting.
Item 25: Avoid overloading on a pointer and a numerical type.
Item 26: Guard against potential ambiguity.
Item 27: Explicitly disallow use of implicitly generated member functions you don't want.
Item 28: Partition the global namespace.

Classes and Functions: Implementation

Item 29: Avoid returning "handles" to internal data.
Item 30: Avoid member functions that return non-const pointers or references to members less accessible than themselves.
Item 31: Never return a reference to a local object or to a dereferenced pointer initialized by new within the function.
Item 32: Postpone variable definitions as long as possible.
Item 33: Use inlining judiciously.
Item 34: Minimize compilation dependencies between files.

Inheritance and Object-Oriented Design

Item 35: Make sure public inheritance models "isa."
Item 36: Differentiate between inheritance of interface and inheritance of implementation.
Item 37: Never redefine an inherited nonvirtual function.
Item 38: Never redefine an inherited default parameter value.
Item 39: Avoid casts down the inheritance hierarchy.
Item 40: Model "has-a" or "is-implemented-in-terms-of" through layering.
Item 41: Differentiate between inheritance and templates.
Item 42: Use private inheritance judiciously.
Item 43: Use multiple inheritance judiciously.
Item 44: Say what you mean; understand what you're saying.

Miscellany

Item 45: Know what functions C++ silently writes and calls.
Item 46: Prefer compile-time and link-time errors to runtime errors.
Item 47: Ensure that non-local static objects are initialized before they're used.
Item 48: Pay attention to compiler warnings.
Item 49: Familiarize yourself with the standard library.
Item 50: Improve your understanding of C++.

Afterward

Index