More About this Title This definitive guide to C++ has been updated to reflect the latest ANSI/ISO standard. With more than 50,000 copies sold, the first edition has helped thousands of developers improve their C++ programming skills. Continuing in this tradition, Meyers has reworked every item in the book and has liberally placed cross-references throughout the text. Table of Contents 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 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++. Afterword Index