Effective C++, Second Edition
Contents

Dedication
Preface
Acknowledgments
Introduction
Shifting from C to C++
|  | Item 1: |  | Prefer `const` and `inline` to `#define`.
Item 2: |  | Prefer `<iostream>` to `<stdio.h>`.
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 sure base classes have virtual destructors.
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++.
Afterword
Index