代码大全

第1章 欢迎进入软件构建的世界 3

1.1 什么是软件构建？ 3

1.2 软件构建为何如此重要？ 6

1.3 如何阅读本书 8

关键点 8

第2章 用隐喻来更充分地理解软件开发 9

2.1 隐喻的重要性 9

2.2 如何使用软件隐喻 11

2.3 常见的软件隐喻 13

软件中的书法：写作代码 13

软件的耕作法：培植系统 14

软件的牡蛎养殖观点：系统生长 15

软件构建：建造软件 16

应用软件技术：智慧工具箱 20

组合各个隐喻 20

更多资源 20

关键点 21

第3章 三思而后行：前期准备 23

3.1 前期准备的重要性 24

前期准备适用于现代软件项目吗？ 25

准备不周全的诱因 25

关于开始构建之前要做前期准备的绝对有力且简明的论据 27

3.2 辨明你所从事的软件的类型 31

迭代开发法对前期准备的影响 33

在序列式开发法和迭代式开发法之间做出选择 35

3.3 问题定义的先决条件 36

3.4 需求的先决条件 38

为什么要有正式的需求？ 38

稳定需求的神话 39

在构建期间处理需求变更 40

3.5 架构的先决条件 43

架构的典型组成部分 45

3.6 花费在前期准备上的时间长度 55

更多资源 56

关键点 59

第4章 关键的“构建”决策 61

4.1 选择编程语言 61

语言描述 63

4.2 编程约定 66

4.3 你在技术浪潮中的位置 66

“深入一种语言去编程”的例子 68

4.4 选择主要的构建实践方法 69

关键点 70

第5章 软件构建中的设计 73

5.1 设计中的挑战 74

设计是一个险恶的问题 74

设计是个了无章法的过程（即使它能得出清爽的成果） 75

设计就是确定取舍和调整顺序的过程 76

设计受到诸多限制 76

设计是不确定的 76

设计是一个启发式过程 76

设计是自然而然形成的 76

5.2 关键的设计概念 77

软件的首要技术任务：管理复杂度 77

理想的设计特征 80

设计的层次 82

5.3 设计构造块：启发式方法 87

寻找现实世界中的对象 87

形成一致的抽象 89

封装实现细节 90

当继承能简化设计时就继承 91

隐藏秘密（信息隐藏） 92

找出容易改变的区域 97

保持松散耦合 100

查阅常用的设计模式 103

其他的启发式方法 105

关于设计启发的总结***** 108

使用启发式方法的原则 109

5.4 设计实践 110

迭代 110

分而治之 111

自上而下和自下而上的设计方法 111

建立试验性原型 114

合作设计 115

要做多少设计才够？ 115

记录你的设计成果 117

5.5 对流行的设计方法的评论 118

更多资源 119

软件设计，一般性问题 119

软件设计理论 120

设计模式 120

广义的设计 121

标准 122

关键点 122

第6章 可以工作的类 125

6.1 类的基础：抽象数据类型 126

需要用到ADT的例子 126

使用ADT的益处 127

更多的ADT示例 129

在非面向对象环境中用ADT处理多份数据实例 131

ADT和类 133

6.2 良好的类接口 133

好的抽象 133

良好的封装 139

6.3 有关设计和实现的问题 143

包含（“有一个……”的关系） 143

继承（“是一个……”关系） 144

成员函数和数据成员 150

构造函数 151

6.4 创建类的原因 152

应该避免的类 155

总结：创建类的理由 155

与具体编程语言相关的问题 156

6.6 超越类：包 156

更多资源 159

关键点 160

第7章 高质量的子程序 161

7.1 创建子程序的正当理由 164

似乎过于简单而没必要写成子程序的操作 166

总结：创建子程序的理由 167

7.2 在子程序层上设计 168

7.3 好的子程序名字 171

7.4 子程序可以写多长 173

7.5 如何使用子程序参数 174

7.6 使用函数时要特别考虑的问题 181

什么时候使用函数，什么时候使用过程 181

设置函数的返回值 182

7.7 宏子程序和内联子程序 182

宏子程序在使用上的限制 184

内联子程序 184

关键点 186

第8章 防范式编程 187

8.1 保护程序免遭无效输入数据的破坏 188

8.2 断言 189

建立自己的断言机制 191

使用断言的指导建议 191

8.3 错误处理技术 194

健壮性与正确性 197

高层次设计对错误处理方式的影响 197

8.4 异常 198

8.5 隔离程序以免遭由错误造成的损害 203

隔离区与断言的关系 205

8.6 辅助调试代码 205

不要自动地把产品版本的限制强加于开发版本之上 205

尽早引入辅助调试的手段 206

采用冒进式编程 206

计划移除调试辅助代码 206

8.7 确定在产品代码中该保留多少防范式代码 209

8.8 防范式编程时保持防范 210

其他资源 212

关键点 213

第9章 伪代码编程过程 215

9.1 创建类和子程序的步骤概述 216

创建一个类的步骤 216

创建子程序的步骤 217

9.2 伪代码 218

9.3 通过伪代码编程过程创建子程序 220

设计子程序 225

编写子程序 225

检查代码 230

收尾工作 232

根据需要重复上述步骤 232

9.4 伪代码编程过程之外的其他方案 232

关键点 234

第10章 使用变量的一般事项 237

10.1 数据认知 238

数据认知测试 238

有关数据类型的其他资源 239

10.2 轻松掌握变量定义 239

隐式声明 239

10.3 变量初始化原则 240

10.4 作用域 244

使变量引用局部化 245

尽可能缩短变量的“存活”时间 246

减小作用域的一般原则 249

有关缩小变量作用域的说明 250

10.5 持续性 251

10.6 绑定时间 252

10.7 数据类型和控制结构之间的关系 254

10.8 为变量指定单一用途 255

关键点 258

第11章 变量名的力量 259

11.1 选择好变量名的注意事项 259

最重要的命名注意事项 260

以问题为导向 261

最适当的名字长度 262

变量名字的效果范围 262

变量名字中的计算值限定词 263

变量名字中的常用反义词 264

11.2 为特定类型的数据命名 264

为循环索引命名 265

为状态变量命名 266

为临时变量命名 267

为布尔变量命名 268

为枚举类型命名 269

为常量命名 270

11.3 命名规则的力量 270

为什么要有规则？ 270

何时采用命名规则 271

正式程度 271

11.4 非正式命名规则 272

语言无关规则的指导原则 272

语言相关规则的指导原则 275

混合语言编程的注意事项 276

命名规则示例 276

11.5 标准前缀 279

用户自定义类型缩写 279

语义前缀 280

标准前缀的优点 281

11.6 创建具备可读性的短名称 282

一般的缩写指导原则 282

语音缩写 282

有关缩写的评论 282

11.7 应该避免的名称 285

关键点 289

第12章 基本数据类型 291

12.1 使用数的普遍规则 292

12.2 整数 293

12.3 浮点数 295

12.4 字符和字符串 297

C中的字符串 299

12.5 布尔变量 301

12.6 枚举类型 303

如果你的语言里没有枚举类型 307

12.7 命名常量 307

12.8 数组 310

12.9 创建你自己的类型（类型别名） 311

为什么创建自己的类型的示例是用Pascal和Ada写的？ 314

创建自定义数据类型的指导原则 315

关键点 318

第13章 不常见的数据类型 319

13.1 结构 319

13.2 指针 323

用来理解指针的例子 323

使用指针的一般技巧 325

C++指针 332

C指针 334

13.3 全局数据 335

与全局数据有关的常见问题 335

使用全局数据的理由 338

只有万不得已时才使用全局数据 339

用访问子程序来取代全局数据 339

如何降低使用全局数据的风险 342

其他资源 343

关键点 344

第14章 组织直线型代码 347

14.1 必须有明确顺序的语句 347

14.2 顺序无关的语句 351

使代码易于自上而下的阅读 351

把相关的语句组织在一起 352

关键点 353

第15章 使用条件语句 355

15.1 if语句 355

简单if-then语句 355

if-then-else语句串 358

15.2 case语句 361

为case选择最有效的排序 361

使用case语句的提示 361

关键点 366

第16章 控制循环 367

16.1 选择循环的种类 367

什么时候使用while循环 368

什么时候用带退出的循环 369

何时使用for循环 372

何时使用foreach循环 372

16.2 循环控制 373

进入循环 373

处理好循环体 375

退出循环 377

检查端点 381

使用循环变量 382

循环应该有多长？ 385

16.3 轻松创建循环——由内而外 385

16.4 循环和数组的关系 387

关键点 389

第17章 不常见的控制结构 391

17.1 子程序中的多个返回 392

17.2 递归 393

递归的例子 394

使用递归的技巧 396

17.3 goto 398

反对goto的论点 398

支持goto的观点 399

关于goto的虚假辩论 400

错误处理和goto 401

goto和在else子句中的共享代码 406

goto使用原则总结 407

17.4 对不常见控制结构的看法 408

其他资源 408

关键点 410

第18章 表驱动方法 411

18.1 表驱动方法使用总则 411

使用表驱动方法的两个问题 412

18.2 直接访问表 413

示例：一个月中的天数（Days-in-Month） 413

示例：保险费率 415

例子：灵活的消息格式（Flexible-Message-Format） 416

构造查询键值 423

18.3 索引表访问（Indexed Access Tables） 425

18.4 阶梯访问表 426

18.5 表查询的其他示例 429

关键点 430

第19章 一般控制问题 431

19.1 布尔表达式 432

用true和false做布尔判断 432

简化复杂的表达式 434

编写肯定形式的布尔表达式 436

用括号使布尔表达式更清晰 438

理解布尔表达式是如何求值的 439

Writing Numeric Expressions in Number-Line Order 441

按照数轴的顺序编写数值表达式 441

Guidelines for Comparisons to 0 442

与0比较的指导原则 442

Common Problems with Boolean Expressions 443

布尔表达式的常见问题 443

19.2 Compound Statements (Blocks) 444

19.2 复合语句（块） 444

19.3 Null Statements 445

19.3 空语句 445

19.4 Taming Dangerously Deep Nesting 446

19.4 驯服危险的深层嵌套 446

Summary of Techniques for Reducing Deep Nesting 454

对减少嵌套层次的技术的总结 454

19.5 A Programming Foundation: Structured Programming 455

19.5 编程基础：结构化编程 455

The Three Components of Structured Programming 455

结构化编程的三个组成部分 455

19.6 Control Structures and Complexity 457

19.6 控制结构与复杂度 457

How Important Is Complexity? 458

复杂度的重要性 458

General Guidelines for Reducing Complexity 458

降低复杂度的一般原则 458

Other Kinds of Complexity 460

其它类型的复杂度 460

CHECKLIST: Control-Structure Issues 460

检查表：控制结构相关事宜 460

Key Points 461

关键点 461