读的是电子版，因为觉得对自己有提升的地方不多，觉得有帮助的都做了相关说明，其他的只是列举了书本的的标题，对于理解的，多说都是费话：

Basics

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
Constructors,Destructors,and Assignment Operators

5>Know what functions c++ silently writes and calls(the time compiler generates a default constructor or when invoking the operator=)
6>Explicitly disallow the use of compiler-generated functions you do not want

7>Declare destructors virtual in polymorphic base classes
c++明确指出，当derived class 对象经由一个base class 指针被删除，而该base class 带着一个non-virtual析构函数，其结果未有定义，实际上通常发生的是对象的derived成分没被销毁。
8>Prevent exceptions from leaving destructors
只要析构函数抛出异常，程序可能过早结束或出现不明确行为

9>Never call virtual functions during construction or destruction(always not virtual in base class when constructing)
10>Have assignment operators return a reference to *this
11>Handle assignment to self in operator=

12>Copy all parts of an object
为derive class 写copying函数时，也应该复制其base class中的成员
Resource Management

13>Use objects to manage resources such as auto_ptr or shared_ptr
14>Think carefully about copying behavior in resource-managing classes(self =)
15>Provide access to raw resources in resource-managing classes
16>Use the same form in corresponding uses of new and delete(if not, undefined)
17>Store newed objects in smart pointers in standalone statements(such as storing a object in a auto_ptr as a standalone object)

18>Make interfaces easy to use correctly and hard to use incorrectly
Designs and Declarations

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>Delcare non-member functions when type convertsions should apply to all parameters

25>Consider support for a non-throwing swap
Implemention
26>Postpone variable definitons as long as possible
使用default构造函数构造一个对象然后对他赋值比直接在构造时指定初值效率差

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 dependencieds between files
Inheritance and Object-Oriented Design

32>Make sure public inheritance models "is-a"
33>Avoid hiding inherited names

34>Differenctiate between inheritance of interface and inheritance of implementation
即便是纯虚函数，也可以有默认实现，而且会被继承和使用，如果在继承类中没有重新实现，则会调用父类中的默认实现。
35>Consider alternatives to virtual functions
函数指针替代virtual，完成某个功能时，把完成功能的函数传进去即可

36>Never redefine an inherited non-virtual function
37>Never redefine a functions's inherited default parameter value
38>Model "has-a" or "is-implemented-in-terms-of" through compositon
39>Use private inhertance judiciously

40>Use multiple inheritance judiciously
virtual public inheritance
Templates and Generic Programming

41>Understanding 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
Customizing new and delete

49>Understand the behavior of the new-handler
50>Understand when it make sense to replace new and delete
51>Adhere to convention when writing new and delete

52>Write placement delete if your write placement new
Miscellany

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