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 newand 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 newand 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-constpointers 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