Translator's Preface
preface
Reviewer's note
Beta Reader's Note
Working principles and terminology band
Hello readers

Chapter 1: When you come to C++, follow the rules of C++.
Item 1: It is essential to view C++ as a union of languages.
Item 2: When using #define, think of const, enum, and inline.
Item 3: If you see any signs of it, try using const!
Item 4: Always initialize an object before using it.

Chapter 2 Constructors, Destructors, and Assignment Operators
Item 5: Be aware of functions that C++ secretly creates and calls.
Item 6: If you don't need compiler-generated functions, definitely avoid using them.
Item 7: In base classes with polymorphism, always declare the destructor as virtual.
Item 8: Prevent exceptions from leaving the destructor.
Item 9: Never call virtual functions during object creation or destruction.
Item 10: Let the assignment operator return a reference to *this.
Item 11: Make sure that self-assignment is not omitted in operator=.
Item 12: Copy all parts of an object without exception.

Chapter 3 Resource Management
Item 13: Stop using objects for resource management!
Item 14: Consider seriously the copy behavior of resource management classes.
Item 15: Ensure that resources managed by resource management classes are accessible from outside.
Item 16: Be sure to use the correct form when using new and delete.
Item 17: Make the code that stores an object created with new in a smart pointer a separate statement.

Chapter 4 Design and Declaration
Item 18: Make interface design easy to use correctly, difficult to use incorrectly.
Item 19: Treat class design the same way as type design.
Item 20: It is usually better to pass by reference to a constant object rather than by value.
Item 21: When you need to return an object from a function, don't try to return a reference.
Item 22: Remember that data members are declared in private areas.
Item 23: Be closer to non-member non-friend functions than to member functions.
Item 24: Declare a non-member function if type conversion must be applied to all parameters.
Item 25: Consider support for swap that doesn't throw exceptions.

Chapter 5 Implementation
Item 26: Be persistent in delaying variable definitions as much as possible.
Item 27: Casting is about saving, saving, saving! Don't forget.
Item 28: Avoid code that returns "handles" to objects used internally.
Item 29: Let's fight and fight again for the day when exceptional safety is secured!
Item 30: Understand inline functions in detail.
Item 31: Minimize compilation dependencies between files.

Chapter 6 Inheritance and Object-Oriented Design
Item 32: Make sure public inheritance models follow "is-a(...is a kind of...)"
Item 33: Avoid hiding inherited names.
Item 34: Understand and distinguish the difference between interface inheritance and implementation inheritance.
Item 35: Develop the habit of thinking about alternatives to virtual functions from time to time.
Item 36: Never redefine inherited non-virtual functions in derived classes!
Item 37: Never override inherited default parameter values ​​for any function.
Item 38: Use object composition when modeling "has-a" or "is-implemented-in-terms-of"
Item 39: Use private inheritance judiciously.
Item 40: Use multiple inheritance judiciously.

Chapter 7 Templates and Generic Programming
Item 41: The journey of template programming begins with implicit interfaces and compile-time polymorphism.
Item 42: Understand the two meanings of typename
Item 43: Know how to access names within templated base classes.
Item 44: Separate parameter-independent code from templates.
Item 45: Member function templates are a shortcut for accepting "any compatible type"!
Item 46: Define non-member functions inside class templates when type conversion is desirable.
Item 47: Use a trait class if you need information about a type.
Item 48: Template metaprogramming, why not?

Chapter 8 New and Delete as I like
Item 49: Understand how the new handler works
Item 50: Know when to swap new and delete to get a better sound
Item 51: Be aware of established conventions when writing new and delete.
Item 52: If you write a positional new, prepare a positional delete as well.

Chapter 9 Other Stories
Item 53: Don't ignore compiler warnings.
Item 54: Become comfortable with standard library components, including TR1.
Item 55: Boo-Ja-I-Know! Boost is always close to you.

Appendix A: Stories After 'Effective C++'
Appendix B: Correspondence Table of Items in the Second and Third Editions

Search