Item 1 : View C++ as a federation of languages. Item 2 : Prefer consts, enums, and inlines to #define. Item 3 : Use const whenever possible. Item 4 : Make sure that objects are initialized before they are used.
Item 5 : Know what functions C++ silently writes and calls. Item 6 : Explicitly disallow the use of compiler-generated functions you do not want. Item 7 : Declare destructions virtual in polymorphic base classes. Item 8 : Prevent exceptions from leaving destructions. Item 9 : Never call virtual functions during constructions or destructions. Item 10 : Have assignment operators return a reference to *this. Item 11 : Handle assignment to self in operator =. Item 12 : Copy all parts of an object.
Item 13 : Use objects to manage resources. Item 14 : Think carefully about copying behavior in resource-managing classes. Item 15 : Provide access to raw resources in resource-managing classes. Item 16 : Use the same form in corresponding uses of new and delete. Item 17 : Store newed objects in smart pointers in standalone statements.
Item 18 : Make interfaces easy to use correctly and hard to use incorrectly. Item 19 : Treat class design as type design. Item 20 : Prefer pass-by-reference-to-const to pass-by-value. Item 21 : Don’t try to return a reference when you must return an object. Item 22 : Declare data members private. Item 23 : Prefer non-member non-friend functions to member functions. Item 24 : Declare non-member functions when type conversions should apply to all parameters. Item 25 : Consider support for non-throwing swap. (!!!NOT UNDERSTAND!!!)
Item 26 : Postpone variable definitions as long as possible. Item 27 : Minimize casting. Item 28 : Avoid returning “handles” to object internals. Item 29 : Strive for exception-safe code. Item 30 : Understand the ins and outs of inlining. Item 31 : Minimize compilation dependencies between files.
Item 32 : Make sure public inheritance models “is-a”. Item 33 : Avoid hiding inherited names. Item 34 : Differentiate between inheritance of interface and inheritance of implementation. Item 35 : Consider alternatives to virtual functions. Item 36 : Never redefine an inherited non-virtual function. Item 37 : Never redefine a functions inherited default parameter value. Item 38 : Model “has-a” or “is-implemented-in-terms-of” through composition. Item 39 : Use private inheritance judiciously. Item 40 : Use multiple inheritance judiciously.
Item 41 : Understand implicit interfaces and compile-time polymorphism. Item 42 : Understand the two meanings of typename. Item 43 : Know how to access names in templatized base classes. Item 44 : Factor parameter-independent code out of template.!!!(ATTENTION)!!! Item 45 : Use member function templates to accept “all compatible types”. Item 46 : Define non-member functions inside templates when type conversions are desired. Item 47 : Use traits classes for information about types. Item 48 : Be aware of template metaprogramming. Item 49 : Understand the behavior of the new-handler. Item 50 : Understand when it makes sense to replace new and delete. Item 51 : Adhere to convention when writing new and delete. Item 52 : Write placement delete if you write placement new.
Item 53 : Pay attention to compiler warnings. Item 54 : Familiarize yourself with the standard library, including TR1. Item 55 : Familiarize yourself with Boost.
