1. 首先让程序运行，然后再追求速度。即使我们确定之一段程序非常重要，而且是我们系统中的瓶颈。不要优化，首先用尽可能简单的设计使程序运行，如果速度不满足要求，再对其进行分析。我们总是能够发现“我们的”瓶颈并不是问题所在。节省我们的时间做真正有意义的事。
2. 编写简洁优美的程序有很多潜在的好处，这不是可有可无的。简洁优美的程序不仅易读，易调试，而且易于理解和维护，这正是能够带来经济利益的地方。这一点只有通过实践才能够体会，因为初看来，使程序简洁优美会影响程序的生产效率，但是，当我们的程序能够无缝地集成进我们的系统，甚至我们的程序需要修改时，就会体现出优点。
3. 记住要“分而治之”。如果感到问题复杂，试着猜测程序的最基本操作，为最难得部分创造一个对象--书写代码并且应用这个对象，然后将这个最难的部分嵌入其他的对象，等等。
4. 不要用C++主动重写我们已有的C代码，除非我们需要对它的功能做较大的调整，（也就是说，如果能用就不要重做）。用C++重新编译时很有价值的，因为这可以发现隐藏的错误。把一段运行得很好的C代码用C++重写可能是在浪费时间，除非C++的版本以类的形式提供许多重用的机会。
5. 如果有很多C代码需要改变，首先隔离不需要修改的代码，最好将那些函数打包成“API类”的静态成员函数。然后集中精力到要修改的代码，将它们精化成类以使以后的维护修改更容易。
6. 要区别类的创建者和类的使用者（客户程序员）。类的使用才是“顾客”，他们并不需要或许也不想知道这类的内部是怎样运作的。类的创建者必须是设计类和编写类的专家，以使得被创建的类可以被最没有经验的程序员使用，而且在应用程序中工作良好。库只是在透明的情况下才会容易使用。
7. 当我们创建一个类时，要尽可能用有意义的名字来命名类。我们的目标应该是使用户接口要简单。可以用函数重载和默认参数来创建一个清楚、易用的借口。
8. 数据隐藏允许我们（类的创建者）将来在不破坏用户代码（代码使用了该类）的情况下随心所欲地修改代码。为了实现这一点，应把对象的成员尽可能定义为private,而只让接口部分为public，而且总是使用函数而不是数据。只有在迫不得已时才让数据为public。如果类的使用者不需要调用这个函数，就让这个函数成为private。如果类的一部分要让派生类可见，就定义为protected，并提供一个函数接口而不是直接暴漏数据，这样，实现部分的改变将对派生类产生最小的影响。
9. 不要陷入分析瘫痪中，有些东西只有在编程时才能学到并使各种系统正常。C++有内建的防火墙，让它们为我们服务。在类或一组类中的错误不会破坏整个系统的完整性。
10. 我们的分析和设计至少要在系统中创建类、他们的公共接口、他们与其他类的关系、特殊的基类。如果我们的方法产生的东西比这些更多，就应当问问自己，是不是所有的成分在程序的整个生命期中都是有价值的，如果不是，将会增加我们对它们的维护开销。开发小组的人都不认为不应该维护对他们的产品没有用的东西。许多设计方法并不大奏效，这是事实。
11. 首先写测试代码（在写类之前），并和类代码一起提交，运用makefile或其他工具使运行测试自动化。这样，在运行测试代码之前就可以自动校验改变，迅速发现错误。因为我们拥有检测错误的体系，所以当发现需要修改代码时，会更大胆地进行尝试。在语言的发展中，最大的进步就是在语言内部建立了类型检查等测试、例外处理等机制。但是这些只能提供给我们这么多，我们应该针对自己的类或程序的特殊性进行测试保证程序的鲁棒性。
12. 首先书写测试代码（在写类代码之前）可以保证类设计的完整性。如果不写测试代码，就不知道我们的类能够做什么。另外，写测试代码的过程会使我们想到类中所需的其他特性或约束条件--这些特性或约束通常在分析和设计阶段不易察觉。
13. 记住软件工程的基本原则：所有的问题都可以通过引进一个额外的间接层来简化。这是抽象方法的基础，而抽象是面向对象编程的首要特征。
14. 尽可能地原子化类。也就是每个类有一个单一、清楚的目的。如果我们的类或我们设计的系统过于复杂，就应当将所有复杂的类分解成多个简单的类。
15. 注意较长的成员函数的定义，长的复杂的函数难于维护，而且很可能这个函数自己做了太多的事情。如果看到这样一个函数，至少预示着应该分解成几个函数，甚至预示着应该创造一个新类。
16. 注意长的参数表，这样函数调用会难写、难读、难于维护。应该把这个成员函数改成一个合适的类，用对象作为参数传递。
17. 不要自我重复。如果一段代码在派生类的许多函数中重复出现，就把这段代码放在基类的一个单一的函数中然后在派生类中调用它。这样我们不仅节省了代码空间，也使将来的修改容易传播。我们可以用内联函数来提高效率。有时发现这种通用代码会为我们的借口添加有用的功能。
18. 注意switch和if-else语句。它们是典型的类型检查编码的指示符。意味着程序运行的情况和哦我们的类型信息有关。（实际的类型并不是最初看起来的类型）我们通常可以将这些代码换成继承和多态，多态函数会为我们进行类型检查，使程序更可靠而且易于扩展。
19. 从设计的角度，寻找并区分那些变化和不变的成分。也就是在系统中寻找那些修改时不需要重新设计的成分，把他们封装到一个类中。
20. 注意不同点。两个语义上不同的对象可能有同样的操作或反应，自然就会试着把一个作为另一个的子类以便利用继承性的好处。这就叫差异，但并没有充分的理由来强制这种并不存在的父子关系。一个好的解决办法是产生一个共同的父类：它包含两个子类--这可能要多占一点空间，但我们可以从继承中获益，并且可能对这种设计有重要发现。
21. 注意在继承过程中的限制。最清晰地设计是向被继承者加入新的功能，而如果在继承过程删除了原有功能，而不是加入新功能，那这个设计就值得怀疑了。但这也不是绝对的，如果我们正在与一个老的类库打交道，对已有的类在子类中进行限制可能更有效，而不必重建一套类层次来使我们的新类适应新的应用。
22. 不要用子类去扩展基类的功能。如果一个类接口部分很关键的话，应当把它放在基类中，而不是在继承中加入。如果我们正在用继承来添加成员函数，我们可能应该重新考虑我们的设计。
23. 一个类一开始时接口部分应尽可能小而精。在类使用过程中，我们会发现需要扩展类的接口。然而一个类一旦投入使用，我们要想减少接口部分，就会影响那些使用了该类的代码，但如果我们我们需要增加函数则不会有影响，一切正常，只需要重新编译一下即可。但即使用新的成员函数取代了原来的功能，也不要去改正原有接口（如果我们愿意的话，可以再低层将两个函数合并。）如果我们需要对一个已有的函数增加参数，我们可以让原来的参数保持不变，把所有新参数作为默认参数，这样不会妨碍对该函数已有的调用。
24. 大声朗读我们的类，确保他们是合理的。读基类时用“is-a”,读成员对象时用“has-a”。
25. 在决定是用继承还是用组合时，问问自己是不是需要向上类型转换到基类。如果不需要，就用组合（成员对象）而不用继承。这样可以减少多重继承的可能。如果我们选择继承，用户会认为他们被假设向上类型转换。
26. 有时我们为了访问基类中的protected成员而采用继承。这可能导致一个可察觉的对多重继承的需求。如果我们不需要向上类型转换，首先导出一个新类来完成保护成员的访问，然后把这个新类作为一个成员对象，放在需要用到它的所有对象中去。
27. 一个典型的基类仅仅是它的派生类的一个借口。当我们创建一个基类时，默认情况下让成员函数都成为纯虚函数。析构函数也可以是纯虚函数（强制派生类对它重新定义）,但记住要给析构函数一个函数体，因为继承关系中所有的析构函数总是被调用。
28. 当我们在类中放一个虚函数时，让这个类的所有函数都成为虚函数，并在类中定义一个虚析构函数。只有当我们要求高效时，而且分析工具指出应该这样做，再把virtual关键字去掉。
29. 用数据成员表示值的变化，用虚函数表示行为的变化。如果我们发现一个类中有几个状态变量和几个成员函数，而成员函数在这些变量的作用下改变行为，我们可能要重新设计它，用子类和虚函数来区分这种不同的作用。
30. 如果我们必须做一些不可移植的事，对这种服务做一个抽象并将它定位在一个类的内部，这个额外的间接层可防止这种不可移植性影响我们的整个程序。
31. 尽量不用多重继承。这可帮助我们摆脱困境，尤其是修复我们无法控制的类的借口时。除非我们是一个经验相当丰富的程序员，否则不要在系统中设计多重继承。
32. 不要用私有继承。虽然C++中可以有私有继承，而且似乎在某些场合下很有用，但它和运行时类型识别一起使用时，常常引起语义的模棱两可。我们可以用一个私有成员对象来代替私有继承。
33. 如果两个类因为一些函数的关系（如容器和迭代器）而联系在一起，使一个类设为公有并将另一个类包含成友元。这不仅强调二者之间的联系，而且允许一个类的名字嵌入到另一个类中复用。标准C++通过在每个容器类中定义嵌入的迭代器类，为容易提供了通用接口。嵌入的另一个原因是可以作为私有运行的一部分。这里，嵌入类之间的联系提供了更大的运行隐藏，而且防止出现上面提到的名字空间污染。
34. 运算符重载仅仅是“语法糖”：另一种函数调用方法。如果重载一个运算符不会使类的接口更清楚、更易于使用，就不要重载它。一个类只创建一个自动类型转换运算符。
35. 首先保证程序能运行，然后再考虑优化。特别是，不要急于写内联函数、使一些函数为非虚函数或者紧缩代码以提高效率。这些在我们开始构建系统时都不用考虑。我们开始的目标应该是证明设计的正确性，除非设计要求一定的效率。
36. 不要让编译器来为我们产生构造函数、析构函数或operator=。类的设计者应该明确地说出类应该做什么，并完全控制这个类。如果我们不想要拷贝构造函数或operator=,就把他们声明为私有的。记住，只要我们产生了任何构造函数，就防止了默认构造函数被生成。
37. 如果我们的类中包含指针，我们必须产生拷贝构造函数、operator=和析构函数，以使类运行正常。
38. 当为派生类写拷贝构造函数时，记住要显示调用基类的拷贝构造函数。如果不这样做，基类会调用默认构造函数，可能这不是我们所想要的情形。要调用基类拷贝构造函数，用以下方式将它传给派生类：Derived(const Derived& d):Base(d){//...
39. 当为派生类写赋值操作符时，记住显示调用基类版本。如果不如此，就不会起作用。应用基类的名字和作用域操作符，调用基类的赋值运算符：
Derived& operator=(const Derived& d){ Base::operator=(d);
40. 为了减少大项目开发过程中的重复编译，应使用句柄类/Cheshire cat技术，只有需要提高运行效率时才把它去掉。
41. 避免用预处理器。可以用常量来代替值，用内联函数代替宏。
42. 保持范围尽可能地小，这样我们的对象的可见性和生命周期也就尽可能地小。这就减少了错用对象和隐藏难以发现的错误的可能性。
43. 避免使用全局变量。尽可能把数据放在类中。全局函数的存在可能性要比全局变量大。一个全局函数作为一个类的静态成员更合适。
44. 如果我们需要声明一个来自库中的类或函数，应该包含一个头文件的方法。
45. 当选择重载运算符的返回值类型时，要考虑表达式连成一串时可能出现的情况：当定义operator=时，应记住x=x。要对左值返回一个拷贝或一个引用，这样才能用在串连表达式中。
46. 当写一个函数时，我们的第一选择是用const引用来传递参数。只要我们不需要修改正在被传递进入的对象，这种方式是最好的。因为它有着传值方式的简单，但不需要费时的构造和析构来产生局部对象，而这在传值方式时是不可避免的。通常我们在设计和构建我们的系统时不用注意效率问题，但养成这种习惯仍是件好事。
47. 当心临时变量。当调整效率时，要注意临时创建的对象，尤其是用运算符重载时。如果我们的构造函数和析构函数很复杂，创建和销毁临时对象就很费时。当从一个函数返回一个值时，总是应在return语句中调用析构函数来“就地”产生一个对象。return MyType(i,j);这优于 MyType x(i,j); return x;
48. 当产生构造函数时，要考虑到异常情况，在最好的情况下，构造函数只是抛出异常，其实是：类只从健壮的类被组合和继承，所以当抛出异常时它们会自动清除它们所作的一切。如果我们必须使用裸指针，我们应该负责捕获自己的异常，然后在我们的构造函数抛出异常以前释放所有指针指向的资源。如果一个构造函数无法避免失败，最好的方法是抛出异常。
49. 在我们的构造函数中只做一些最必要的事情，这不仅使构造函数的调用有较低的时间花费，而且我们的构造函数更少地抛出异常和引用问题。
50. 析构函数的作用是释放在对象的整个生命期内分配的所有资源，而不仅仅是在创建期间。
51. 使用异常层次，最好从标准C++异常层次中继承，并作为公共类嵌入能抛出异常的类中。捕获异常的人然后可以确定异常的类型。如果我们加上新的派生异常，已存在的客户代码还是通过基类来捕获这个异常。
52. 用值来抛出异常，用引用来捕获异常。让异常处理机制处理内存管理。如果我们抛出一个指向在堆上产生的异常的指针，则捕获者必须破坏这个异常，这事一种不利的耦合。如果我们用值来捕获异常，我们需要额外的构造和析构，更糟的是，我们的异常对象的派生部分可能在以值向上类型转换时被切片。
53. 除非确有必要，否则不要写自己的类模板。先查看一个标准模板库，然后查问创建特殊工具的开发商。当我们熟悉了这些产品后，我们就可大大提高我们的生产效率。
54. 当创建模板时，留心那些带类型的代码并把它们放在非模板的基类中，以防不必要的代码膨胀。用继承或组合，我们可以产生自己的模板，模板中包含的大量代码都应是必要的，类型相关的。
55. 不要用<cstdio>函数，例如printf()。学会用输入输出流来代替，他们是安全和可扩展类型，而且功能也更强。我们在这上面花费的时间肯定不会白费。一般情况下都要尽可能用C++中的库而不要用C库。
56. 不要用C的内部数据类型，虽然C++为了向后兼容仍然支持他们，但他们不像C++的类那样强壮，所以这会增加我们查找错误的时间。
57. 无论何时，如果我们用一个内部数据类型作为一个全局或自动变量，在我们可以初始化他们之前不要定义他们。每一行定义一个变量，并同时对它初始化。当定义指针时，把"*"紧靠在类型的名字一边。如果我们每个变量占一行，我们就可以很安全地定义他们。
58. 保证在所有代码前面初始化。在构造函数初始化表中完成所有成员的初始化，甚至包括内部数据类型。在初始化子对象时用构造函数初始化表常常更有效；否则调用了默认构造函数，而不再调用使初始化正确的其他成员函数。
59. 不要用“MyType a = b”的形式来定义一个对象。这是常常引起混乱的原因。因为它调用构造函数来代替operator=。为了清除起见，可以用“MyType a(b)”来代替。这个语句结果是一样的，但不会引起混乱。
60. 使用C++显示类型转换。类型转换重载了正常的类型系统，它往往是潜在的错误点。
61. 为了使一个程序更健壮，每个组件都必须是很强壮的。在我们创建的类中运用C++中提供的所有工具：隐藏实现、异常、常量更正、类型检查等等。用这些方法我们可以再构造系统时安全地转移到下一个抽象层次。
62. 建立常量更正。这允许编译器指出一些非常细微且难以发现的错误。
63. 充分利用编译器的错误检查功能，用完全警告方式编译我们的全部代码，修改我们代码，直到消除所有的警告为止。在我们的代码中宁可犯编译错误也不要犯运行错误。用assert来调试，对运行时错误要进行异常处理。
64. 宁可犯编译错误也不要犯运行错误。处理错误的代码离出错点越近越好。尽量就地处理错误而不要抛出异常。用最近的异常处理器处理所有的异常，这里它有足够的信息处理它们。在当前层次上处理我们能解决的异常，如果解决不了，重新抛出这个异常。
65. 如果一个析构函数调用了任何函数，这些函数都可能抛出异常。一个析构函数不能抛出异常。所以任何调用了其他函数的析构函数都应该捕获和管理它自己的异常。
66. 不要自己创建私有数据成员名字“修饰”，除非我们有许多已在的全局值，否则让类和名字空间来为我们做这些事。
67. 注意重载，一个函数不应该用某一个参数的值来决定执行哪段代码，如果遇到这种情况，应该产生两个或多个重载函数来代替。
68. 把指针隐藏在容器中。只有当我们要对它们执行一个立即可以完成的操作时才把他们带出来。
69. 不要重载全局new和delete，可以在类的基础上去重载它们。
70. 防止对象切片。实际上以值向上类型转换到一个对象毫无意义。为了防止这样，在我们的基类中放入一些纯虚函数。
