Effective C++ by Scott Meyers (Short Summary)
  • Introduction
  • Chapter 1 - Accustoming Yourself to C++
    • 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
    • Item 5 - Know what functions C++ silently writes a calls.
    • Item 6 - Explicitly disallow the use of compiler-generated functions you do not want.
    • Item 7 - Declare destructors virtual in polymorphic base classes.
    • Item 8 - Prevent exceptions from leaving destructors.
    • Item 9 - Never call virtual functions during construction or destruction.
    • 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.
  • Chapter 3 - Resource Management
    • 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.
  • Chapter 4 - Designs and Declarations
    • 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 a non-throwing swap.
Powered by GitBook
On this page
  1. Chapter 1 - Accustoming Yourself to C++

Item 1 - View C++ as a federation of languages.

In the beginning, C++ was just C with some object-oriented features tacked on, but today C++ is a multiparadigm programming language, one supoorting a combination of procedural, object-oriented, functional, generic and metaprogramming features. The easiest way is to view C++ not as a single language but as a federation of related languages within a particular sublanguage, the rules tend to be simple, straightforward, and easy to remember. To make sense of C++, one has to recognize its primary sub-languages. Fortunately, there are only four:

  • C. Way down step, C++ still based on C. Blocks, statements, the preprocessor, built-in data types, array, pointers, etc., all come from C.

  • Object-Oriented C++. This part of C++ is what C with Classes was all about: classes (including constructors and destructors), encapsulation, inheritance, polymorphism, virtual functions (dynamic binding), etc.This is the part of C++ to which the classic rules for object-oriented design most directly apply.

  • Template C++. This is the generic programming part of C++, the one that most programmers have the least experience with. Template considerations pervade C++, and it's not uncommon for rules of good programming to include special template-only clauses. Infact, templates are so powerful, they give rise to a complete new programming paradigm, Template Meta Programming TMP.

  • The STL. The STL is a template library, of course, but it's a very special template library. Its conventions regarding containers, iterators, algorithms, and function objects mesh beautifullu, but templates and libraries can be built around other ideas too.

Things to Remember:

  • Rules for effective C++ programming vary, depending on the part of C++ you are using.

PreviousChapter 1 - Accustoming Yourself to C++NextItem 2 - Prefer consts, enums, and inlines to #defines.

Last updated 3 years ago