I've listed the table of contents from Effective C++ by Scott Meyers below.

Table of Contents

Chapter 1: Accustoming Yourself to C++

1 View C++ as a federation of languages.
2 Prefer consts, enums, and inlines to #defines.
3 Use const whenever possible.
4 Make sure that objects are initialized before they're used.

Chapter 2: Constructors, Destructors, and Assignment Operators

5 Know what functions C++ silently writes and calls.
6 Explicitly disallow the use of compiler-generated functions you do not want.
7 Declare destructors virtual in polymorphic base classes.
8 Prevent exceptions from leaving destructors.
9 Never call virtual functions during construction or destruction.
10 Have assignment operators return a reference to this.
11 Handle assignment to self in operator=.
12 Copy all parts of an object.

Chapter 3: Resource Management

13 Use objects to manage resources.
14 Think carefully about copying behavior in resource-managing classes.
15 Provide access to raw resources in resource-managing classes.
16 Use the same form in corresponding uses of new and delete.
17 Store newed objects in smart pointers in standalone statements.

Chapter 4: Designs and Declarations

18 Make interfaces easy to use correctly and hard to use incorrectly.
19 Treat class design as type design.
20 Prefer pass-by-reference-to-const to pass-by-value.
21 Don't try to return a reference when you must return an object.
22 Declare data members private.
23 Prefer non-member non-friend functions to member functions.
24 Declare non-member functions when type conversions should apply to all parameters.
25 Consider support for a non-throwing swap.

Chapter 5: Implementations

26 Postpone variable definitions as long as possible.
27 Minimize casting.
28 Avoid returning "handles" to object internals.
29 Strive for exception-safe code.
30 Understand the ins and outs of inlining.
31 Minimize compilation dependencies between files.

Chapter 6: Inheritance and Object-Oriented Design

32 Make sure public inheritance models "is-a."
33 Avoid hiding inherited names.
34 Differentiate between inheritance of interface and inheritance of implementation.
35 Consider alternatives to virtual functions.
36 Never redefine an inherited non-virtual function.
37 Never redefine a function's inherited default parameter value.
38 Model "has-a" or "is-implemented-in-terms-of" through composition.
39 Use private inheritance judiciously.
40 Use multiple inheritance judiciously.

Chapter 7: Templates and Generic Programming

41 Understand implicit interfaces and compile-time polymorphism.
42 Understand the two meanings of typename.
43 Know how to access names in templatized base classes.
44 Factor parameter-independent code out of templates.
45 Use member function templates to accept "all compatible types."
46 Define non-member functions inside templates when type conversions are desired.
47 Use traits classes for information about types.
48 Be aware of template metaprogramming.

Chapter 8: Customizing `new` and `delete`

49 Understand the behavior of the new-handler.
50 Understand when it makes sense to replace new and delete.
51 Adhere to convention when writing new and delete.
52 Write placement delete if you write placement new.

Chapter 9: Miscellany

53 Pay attention to compiler warnings.
54 Familiarize yourself with the standard library, including TR1.
55 Familiarize yourself with Boost.