Chapter 1. Accustoming Yourself to C++ [Note]
Item 1. View C++ as a federation of languages.
Item 2. Prefer consts, enums, and inlines to #defines.
Item 3. Use const whenever possible.
Item 4. Make sure that objects are initialized before they’re used.
Chapter 2. Constructors, Destructors, and Assignment Operators [Note]
Items 5: know what functions C++ silently writes and calls
Items 6: Explicitly disallow compiler-generated functions you do not want
Items 7: Declare destructor virtual in polymorphic base class
Items 8: Prevent exceptions from leaving destructors
Items 9: Never call virtual functions during construction and deconstruction
Items 10: Have assignment operators returns a reference to *this
Items 11: Handle assignment to self in operator=
Items 12: Copy all parts of an object
Chapter 3. Resource Management [Note]
Items 13: Using objects to manage resource
Items 14: Think carefully about copying behavior in resource-managing classes
Items 15: Provide access to raw resource in resource manage class
Items 16: Use the same form in corresponding uses of new and delete
Items 17: Store newed objects in smart pointers in standalone statements
Chapter 4. Designs and Declarations [Note]
Items 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
Items 23 Prefer non-member non-friend functions to member functions
Items 24: Declare non-member functions when type conversion should apply to all parameters
Items 25: consider supporting for a non-throwing swap
Chapter 5. Implementations [Note]
Item 26: Postpone variable definition 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
Chapter 6. Inheritance and Object-Oriented Design [Note]
Item32: Make sure public inheritance models “is-a”
Item 33: Avoid hiding inherited names
Item34: Differentiate between inheritance of interface and inheritance of implementation
Item35: Consider alternatives to virtual functions
Item36: Never redefine an inherited non-virtual function
Item37: Never redefine a function’s inherited default parameter value
Item38: Model “has-a” or “is-implemented-in-terms-of” through composition
Item39: Use private inheritance judiciously
Item40: Use multiple inheritance judiciously
Chapter 7. Templates and Generic Programming [Note]
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 template base classes
Item 44: Factor parameter-independent code out of templates
Item 45: Use member function templates to accept “all compatible types”
Item46: Define non-member function when type conversion is needed
Item47: Use traits classes for information about types
Item48: Be aware of template meta-programming
Chapter 8. Customizing ‘new’ and ‘delete’ [Note]
Item49: Understand the behavior of the new-handler
Item50: Understand when it makes sense to replace new and delete
Item51: Adhere to convention when writing new and delete
Item52: Write placement delete if you write placement new
Chapter 9. Miscellany [Note]
Item53: Pay attention to compiler warnings
Item 54: Familiarize yourself with the standard library, including TR1
Item 55: Familiarize yourself with Boost