第14章，组织直线型代码
14.1 必须有明确顺序的语句
针对接口编程而不是针对实现编程，则要求接口没有假定，或者假定很明显。
1、 设法组织代码，使依赖关系变得明显。
2、 使子程序名称能够明显的表示依赖关系。
3、 利用子程序参数明确表示依赖关系。
4、 用注释对不清晰的依赖关系进行说明。
5、 用断言或错误处理代码来检查依赖关系。
14.2 顺序无关的语句
如果语句间没有依赖关系，则可以根据第二标准来来判断语句或代码块的顺序：就近原则（Principle of proximity ） 。
1、 使代码易于自上而下的阅读。
2、 把相关的语句组织在一起。如果相关语句的管理性很强则要考虑形成一个新的子程序。
本章要点
1、 组织直线型代码最主要的原则是按照依赖关系进行排列。
2、 可以用好的子程序名，参数列表，注释以及——如果代码足够重要——内务变量（类内部的状态变量）来使依赖关系变得更加明显。
3、 如果代码之间没有依赖关系，那就设法使相关的语句尽可能的接近。
第15章 使用条件语句
15.1 if 语句
简单 if-then 语句：
1、 首先写正常的代码路径，再处理不常见的情况。
2、 确保对于等量的分支是正确的。
3、 把正常的情况放在 if 后面而不是 else后面。
4、 让 if 后面跟一个有意义的句子。
5、 考虑 else子句 有些规范要求 if 后面必须跟 else语句有助于促使程序员考虑 else的情况 。
6、 测试 else子句。
7、 检查 if 和 else是否弄反了。
If-then-else 语句串：
1、 利用布尔函数调用简化逻辑判断 对于复杂的布尔判断，用一个函数进行封装。
2、 把常见的放在最前面。可以提高可读性和性能。
3、 确保所有的情况都考虑到了。
4、 如果语言支持，将它更改为其他的结构。
15.2 case语句
为 case选择最有效的排列顺序：
1、 按字母或数字顺序排序。
2、 把正常的情况放在前面。
3、 按执行频率排列 case子句。
使用 case语句的诀窍：
1、 简化每种情况对应的操作：使用函数。
2、 不要为了使用 case语句而构造一个费解的变量。
3、 把 default 语句只用于检查真正的默认情况。
4、 利用 default 语句来检查错误。在 c++和 Java中，避免代码执行越过一条 case语句的结尾。
5、 在c++中，在 case末尾明确无误的表明需要穿越执行的程序流程。
第16章 控制循环
16.1 选择循环的种类
什么时候使用 while 循环：
什么时候使用带退出的循环：
如果把循环条件放在开始或结束处，那就要写一个半循环。 还要注意把所有的退出条件放在一起，避免将它写的到处都是。带退出的循环更容易理解。
什么时候使用 for 循环：
不需要在内部控制循环， 循环条件是简单的递增或递减。 如果更为复杂， 则要使用 while循环。
16.2 循环控制
防止循环错误的方法： 1）减少能够影响该循环的各种因素的数量。 2）把循环体内部看做一个子程序，把循环控制放在循环体外部。
进入循环：
1、 只从同一个位置进入循环。
2、 把初始化代码紧放在循环前面。就近原则主张把相关的语句放在一起。如果分开放置，在后期的维护过程中，对程序的更改容易产生错误。
3、 用 while（true）表示无限循环。
4、 在适当的情况下多使用 for 循环。For 循环将循环控制代码集中在一处。 从而有助于形成可读性强的代码。
5、 在 while 循环更适用的时候，使用 while 循环。不要把和循环无关的代码放在循环头部。
处理好循环体：
1、 用{} 将循环体括起来。
2、 避免空循环。有时候如果把循环检测和循环执行放在循环头中，会出现这种情况。
3、 把循环内务操作（？循环的内务操作是指向 i++ ，j++之类的循环控制操作）要么放在循环的开始，要么放在循环的结尾。
4、 一个循环只做一件事情。
退出循环：
1、 设法确认循环可以终止。
2、 循环终止条件看起来很明显。
3、 不要为了推出循环而胡乱的更改下标。为了获得对循环更多的控制权，可以使用 while循环来实现。
4、 避免出现依赖于循环下标最终取值的代码。 更好的具有自描述的做法是， 定义一个变量 ，将循环下标赋值给它。
5、 使用安全计数器：用于在如果循环过多会产生灾难性后果的情况下使用。
提前退出循环：
1、 考虑在 while 循环中使用 break 语句而不是使用布尔标记。
2、 对循环中存在过多 break 语句的情况提高警惕。
3、 在循环开始处使用 continue，可以代替 if 判断，提高可读性。
4、 对 continue 和 break 的使用保持警惕。它会增加复杂度。
检查端点：
使用循环变量：
1、 用整数或者枚举类型表示数组和循环边界。
2、 在嵌套循环中使用有意义的变量名来提高其可读性。如果是你使用的二维或者多维的数组，也使用含有意义的变量来表示其数组名称。避免使用 i，j，k 等无意义的名称。
3、 用有意义的名字来避免循环下标串话。
4、 把循环变量的作用域限制于循环内部。
循环应该有多长：
1、 循环要尽可能的短，以便能够一目了然。 尝试“编写简单代码的原则”，那么会很少写出超过20行的循环。一般的，一个函数在7行左右。
2、 把嵌套控制3层内。提取子程序来优化。
3、 把循环体内部的长的语句提取层一个子程序。
4、 要让长循环格外清晰。
16.3 轻松创建循环——由内而外
先写一个一般的过程，再把这个过程用循环代替。
本章要点
1、 循环很复杂，保持循环简单将有助于别人阅读你的代码。
2、 保持循环简单的技巧：避免使用诡异的循环，减少嵌套层次，让入口和出口一目了然，把内务操作代码放在一起。
3、 循环下标很容易滥用，因此命名要准确，并且把他们各自仅用于一个用途。
4、 仔细考虑循环，确认他在每一种情况下都可以运行正常，并且在没一种情况下都可以退出循环。
第十七章，不常见的控制结构
谨慎的使用这些控制结构，将会获得更多的帮助。
17.1 子程序中有多处返回
1、 如果能够增强可读性，那么就是用 return。
2、 用防卫子句来简化复杂的错误处理。
3、 减少子程序中 return 的数量。
17.2 递归
使用递归的技巧：
1、 确认递归能够停止。
2、 使用安全计数器防止出现无穷递归。
3、 把递归限制在一个子程序中。
4、 留心栈空间。
5、 不要用递归计算阶乘和斐波那契数列。
本章要点
多个 return 可以提高子程序的可读性，同时避免产生很深的嵌套逻辑。
第十八章，表驱动法
表驱动法是一种编程模型（scheme）——从表中查找信息而不是使用逻辑语句（if或else）。
对于表驱动法一定要慎用。如果逻辑很复杂，导致逻辑判断链很长，使用表驱动法有助于降低复杂度。否则，表驱动法只会增加复杂度。
18.1 表驱动法使用总则
使用表驱动法的两个问题：
1、 如何从表中查询条目。三种方法：直接访问（Directory access） 表，索引访问（Index access）表，阶梯访问（ Stair-step access）表。
2、 表中要保存什么。可能是数据，函数指针，对象实例等。
18.2 直接访问表
灵活的消息格式：
这里介绍了一个通用的表驱动法。核心的思想仍然是通过抽象，隔离变化，使变化的影响降低到最低，使代码对变化是友好的。
构造查询键值：
1、 复制信息从而能够直接使用键值。
2、 转换键值以使其能够直接使用。对键值进行转换，得到直接的索引值。这里可以在增加一个新的查询表。
3、 把键值转换提取层单独的子程序。
18.3 索引访问表
18.4 阶梯访问表
基本思想：表中的记录对于不同的数据范围有效，而不是对不同的数据点有效。
注意细节：
1、 留心端点。
2、 考虑用二分查找代替顺序查找。
3、 考虑用索引访问代替阶梯访问。索引访问速度快，占内存。阶梯访问速度慢，省内存。
4、 把阶梯中的查询操作提取成单独的子程序。
本章要点
1、 表提供了一种复杂的逻辑和继承结构的替代方案。如果你发现自己对某个程序的逻辑和继承关系感到困惑时，那么问问自己它是否可以通过一个查询表来简化。
2、 使用表的一项关键决策时如何去访问表。你可以采取直接访问，索引访问，或者阶梯访问。
3、 使用表的另一项关键决策时把什么内容放在表中。
把表驱动法写成一个基础库。
第十九章，一般控制问题
19.1 布尔表达式
用 TRUE 和 FALSE 做布尔判断。
简化复杂的表达式：
1、 拆分复杂的判断并引入 的布尔变量。
2、 把复杂的表达式做成布尔函数。
3、 用决策表代替复杂的条件。
编写肯定形式的布尔表达式
1、 在 if 语句中，把判断条件从否定形式转化为肯定形式。并且互换 if 和 else中的代码。
2、 用狄摩根定理简化否定的布尔判断——将 not a and not b ---> not ()
用括号使布尔表达式清楚
按照数值的顺序编写数值表达式
与 0 比较的指导原则：
1、 隐式的比较逻辑变量： if (!done)
2、 把数和 0 比较： if (balance != 0)
3、 在 c中显示的比较字符和零终止符（ ’\0 ’ ）while (*charPtr != ‘0’)
4、 指针与 NULL 比较。
布尔表达式的常见问题
1、 在 c家族语言中，应该把常量放在比较的左端。
2、 在 Java中， a==b 表示 a和 b 是否引用同一个变量。
3、 a.equals(b)a和 b是否相同。
19.2 复合语句
if 后面即便是只有一条语句，也用括号括起来。
19.3 空语句
1、 小心使用空语句
2、 为空语句创建一个 DoNothing() 预处理宏或者内联函数。
3、 使用非空的循环体进行优化。使用更加直截了当的编程方法。而不是自作聪明的使用循环的副作用。
19.4 驯服危险的深层嵌套
深层嵌套会降低程序的可读性，增加复杂性。
避免的方法：
1、 重复检查条件来简化嵌套。把一个大的嵌套，更改为几个小的嵌套。最外面的条件判断是重复的。
2、 用 break 来简化嵌套。不是一个很好的办法。
3、 把嵌套 if 简化为一组 if-then-else。
4、 把 if 转换为 case
5、 把申请嵌套抽取出来放进单独的子程序中。最好的一个方法。
6、 一个更面向对象的方法。用面向对象来代替复杂的嵌套
7、 重新设计深层嵌套的代码：如果层次很深，则说明你对这一段代码的理解不深刻。
19.5 编程基础：结构化编程
结构化编程的三个组成部分：
1、 顺序
2、 选择
3、 迭代：循环
中心：任何一种控制流都可以由顺序，选择和迭代这三种结构生成。对于除这三种之外的任何控制结构—— break，continue ，return ，throw-watch ——都要持一种批判的态度。
19.6 控制结构与复杂度
程序复杂度的一个衡量标准：为了理解程序，你必须在同一时间记住的智力实体的数量。
控制流是程序复杂度的一个很重要的方面（其他的包括变量的个数） 。
对于任何规则的使用，都要记住：没有绝对的真理，也没有绝对的谬论。要具体情况具体分析，这才是设计的灵魂。绝对的真理让我们盲从，绝对的谬论让我们偏执。
如何度量复杂度：
计算机子程序中决策点数量的技术
1、 从 1 开始，一直往下通过程序。
2、 一旦遇到以下关键字，或者同类的词，就加 1：if，while，repeat，fo
3、 给 case中的每一种情况加 1。
如何处理复杂度的度量结果：
1、 0—5：子程序可能还不错。
2、 6—10：得想办法优化。
3、 10+：把子程序的某一部分拆分成另外一个子程序并调用它。
其他类型的复杂度：
1、 所用的数据量。
2、 控制结构中的嵌套层次。
3、 代码行数。
4、 对同一变量的先后引用之间的代码行数（跨度） 。
5、 变量生存的代码行数（生存期） 。
6、 输入输出的量
本章要点
1、 使布尔表达式简单可读，将有助于提高你的代码质量。
2、 深层次的嵌套使得代码难于理解，所幸的是，你可以相对容易的避免这么做。
3、 结构化编程是一种简单并且依然适用的思想，你可以通过把顺序、选择、循环三者结合起来而开发出任何程序。
4、 将复杂度降低到最低水平式编写高质量代码的关键。