第1篇 代码表面 3
第1章 善于防守：健壮代码的防御性编程技巧 3
1.1向优秀的代码前进 3
1.2设想：最坏的选择 4
1.3什么是防御性编程？ 6
1.4又大又坏的世界 8
1.5防御性编程技巧 9
1.5.1使用好的编码风格和合理的设计 9
1.5.2不要仓促地编写代码 9
1.5.3不要相信任何人 10
1.5.4编码的目标是清晰，而不是简洁 11
1.5.5不要让任何人做他们不该做的修补工作 11
1.5.6编译时打开所有警告开关 12
1.5.7使用静态分析工具 13
1.5.8使用安全的数据结构 13
1.5.9检查所有的返回值 14
1.5.10审慎地处理内存（和其他宝贵的资源） 14
1.5.11在声明位置初始化所有变量 15
1.5.12尽可能推迟一些声明变量 15
1.5.13使用标准语言工具 15
1.5.14使用好的诊断信息日志工具 16
1.5.15审慎地进行强制转换 16
1.5.16细则 16
1.6约束 17
1.6.1约束的内容 19
1.6.2移除约束 19
1.7总结 22
1.8另请参见 22
1.9思考 24
1.9.1深入思考 24
1.9.2结合自己 24
第2章 精心布局：源代码的版面和样式 26
2.1什么是关键 27
2.2了解你的读者 27
2.3什么是好的样式 29
2.4使用括号 30
2.4.1 K&R括号风格 30
2.4.2悬挂式的括号风格 31
2.4.3缩进的括号风格 32
2.4.4其他的括号风格 33
2.5主宰一切的风格 33
2.6内部风格（以及在哪里使用它们） 35
2.7设立标准 37
2.8正义的战争 39
2.9总结 40
2.10另请参见 42
2.11思考 42
2.11.1深入思考 42
2.11.2结合自己 43
第3章 名正言顺：为有意义的事物起有意义的名称 45
3.1为什么我们应该恰当地命名呢 47
3.2我们对什么进行命名 47
3.3名字游戏 48
3.3.1描述性 48
3.3.2技术上正确 48
3.3.3符合语言习惯 49
3.3.4恰当 49
3.4具体细节 50
3.4.1命名变量 51
3.4.2命名函数 52
3.4.3命名类型 53
3.4.4命名名字空间 54
3.4.5命名宏 55
3.4.6命名文件 56
3.5玫瑰不叫玫瑰 57
3.5.1保持前后一致 58
3.5.2利用上下文 58
3.5.3使用对你有利的名称 59
3.6总结 59
3.7另请参见 61
3.8思考 62
3.8.1深入思考 62
3.8.2结合自己 63
第4章 不言自明：编写“自文档化”代码的技巧 64
4.1自文档化的代码 66
4.2编写自文档化代码的技术 69
4.2.1使用好的样式编写简单的代码 69
4.2.2选择有意义的名称 70
4.2.3分解为原子函数 70
4.2.4选择描述性的类型 71
4.2.5命名常量 71
4.2.6强调重要的代码 72
4.2.7分组相关信息 72
4.2.8提供文件头 72
4.2.9恰当地处理错误 73
4.2.10编写有意义的注释 73
4.3实用的自文档化方法 74
4.3.1文学性编程 74
4.3.2文档化工具 76
4.4总结 78
4.5另请参见 79
4.6思考 79
4.6.1深入思考 79
4.6.2结合自己 81
第5章 随篇注释：如何编写代码注释 82
5.1什么是代码注释 83
5.2注释看上去是什么样的 84
5.3多少注释是恰当的 84
5.4注释中应该有些什么 85
5.4.1解释为什么，而不是怎么样 85
5.4.2不要描述代码 86
5.4.3不要取代代码 86
5.4.4确保注释有用 86
5.4.5避免分心 88
5.5实践 88
5.6从审美的角度看注释 89
5.6.1一致性 89
5.6.2清晰的块注释 90
5.6.3缩进的注释 90
5.6.4行尾注释 91
5.6.5帮助你阅读代码 91
5.6.6选择一种维护成本较低的风格 92
5.6.7分隔板 92
5.6.8标志 92
5.6.9文件头注释 93
5.7使用注释 94
5.7.1帮助你编写例行程序 94
5.7.2错误修正通告 95
5.7.3注释过时 95
5.7.4维护和空洞无物的注释 96
5.8总结 97
5.9另请参见 98
5.10思考 98
5.10.1深入思考 98
5.10.2结合自己 99
第6章 人非圣贤：处理不可避免的情况——代码中的错误情形 100
6.1从何而来 101
6.2错误报告机制 102
6.2.1不报告 103
6.2.2返回值 103
6.2.3错误状态变量 104
6.2.4异常 104
6.2.5信号 106
6.3检测错误 107
6.4处理错误 108
6.4.1何时处理错误 109
6.4.2可能的反应 110
6.4.3代码示例 112
6.5使地狱浮现 116
6.6管理错误 118
6.7总结 119
6.8另请参见 119
6.9思考 120
6.9.1深入思考 120
6.9.2结合自己 121
第2篇 代码的神秘生命 125
第7章 欲善其事，先利其器：使用工具构建软件 125
7.1什么是软件工具 126
7.2为什么要在意工具 128
7.3使工具发挥作用 129
7.3.1了解它能做些什么 130
7.3.2学习如何驾驭它 130
7.3.3了解它适合什么任务 131
7.3.4检查它是否可用 131
7.3.5找到了解更多信息的途径 131
7.3.6查明新版本何时出现 132
7.4哪个工具 132
7.4.1源代码编辑工具 133
7.4.2代码构建工具 136
7.4.3调试和调查工具 138
7.4.4语言支持工具 140
7.4.5其他工具 141
7.5总结 142
7.6另请参见 143
7.7思考 144
7.7.1深入思考 144
7.7.2结合自己 145
第8章 测试时代：测试代码的魔术 146
8.1反思现实 148
8.2谁、是什么、何时以及为什么 149
8.2.1我们为什么要测试 149
8.2.2谁来进行测试 150
8.2.3测试的内容有些什么 150
8.2.4何时进行测试 151
8.3测试并不难 152
8.4测试的类型 156
8.5选择单元测试用例 160
8.6为测试而设计 163
8.7看！不要用手 164
8.8面对故障该怎么办 165
8.9你能管理它吗 166
8.9.1缺陷跟踪系统 166
8.9.2 bug审查 168
8.10总结 169
8.11另请参见 169
8.12思考 170
8.12.1深入思考 170
8.12.2结合自己 171
第9章 寻找缺陷（调试）：当事情进展得不顺利时该怎么办 172
9.1生活的真相 173
9.2 bug的种类 174
9.2.1从远处看 174
9.2.2从近处看 175
9.2.3从更近处看 178
9.3消灭害虫 180
9.3.1地下之路 181
9.3.2地上之路 181
9.4搜寻bug 182
9.4.1编译时错误 182
9.4.2运行时错误 184
9.5如何修正缺陷 188
9.6预防 190
9.7除蜂剂、驱虫剂、捕蝇纸 190
9.7.1调试器 190
9.7.2内存访问校验器 191
9.7.3系统调用跟踪 191
9.7.4内核转储 191
9.7.5日志 191
9.8总结 192
9.9另请参见 193
9.10思考 194
9.10.1深入思考 194
9.10.2结合自己 194
第10章 代码构建：将源代码转换为可执行代码的过程 196
10.1语言障碍 197
10.1.1解释型语言 198
10.1.2编译型语言 199
10.1.3字节编译型语言 200
10.2小题大做 201
10.3构建软件版本 203
10.4怎样才算是一个优秀的构建系统 206
10.4.1简洁 206
10.4.2一致 207
10.4.3可重复和可靠 207
10.4.4原子性 208
10.4.5能够应付错误 209
10.5技术细节 210
10.5.1目标的选择 210
10.5.2内务处理 212
10.5.3依赖关系 212
10.5.4自动构建 213
10.5.5构建配置 214
10.5.6递归地使用make 215
10.6请发布我吧 215
10.7构建大师是全能的吗 218
10.8总结 218
10.9另请参见 219
10.10思考 219
10.10.1深入思考 220
10.10.2结合自己 220
第11章 追求速度：优化程序和编写高效的代码 222
11.1优化是什么 223
11.2是什么使代码不尽如人意 224
11.3为什么不进行优化呢 225
11.4为什么要进行优化 228
11.5优化的具体细节 229
11.5.1证明你需要进行优化 230
11.5.2找出运行得最慢的代码 230
11.5.3测试代码 232
11.5.4优化代码 233
11.5.5优化之后 233
11.6优化的技术 233
11.6.1设计更改 234
11.6.2代码更改 237
11.7编写高效的代码 241
11.8总结 243
11.9另请参见 244
11.10思考 244
11.10.1深入思考 244
11.10.2结合自己 245
第12章 不安全感综合征：编写安全的程序 247
12.1危险 248
12.2敌人 250
12.3借口，都是借口 252
12.4感到很脆弱 253
12.4.1不安全的设计和体系结构 253
12.4.2缓冲溢出 254
12.4.3嵌入的查询字符串 255
12.4.4竞争状况 255
12.4.5整数溢出 256
12.5防范措施 257
12.5.1系统安装技术 258
12.5.2软件设计技术 258
12.5.3代码实现技术 260
12.5.4规程技术 261
12.6总结 261
12.7另请参见 262
12.8思考 263
12.8.1深入思考 263
12.8.2结合自己 263
第3篇 代码的形成过程 267
第13章 崇尚设计：如何创作出优秀的软件设计 267
13.1边设计边编程 268
13.2我们要设计什么 269
13.3为什么这么忙乱 270
13.4良好的软件设计 271
13.4.1简洁 272
13.4.2优雅 273
13.4.3模块化 274
13.4.4良好的接口 275
13.4.5可扩展性 278
13.4.6避免重复 278
13.4.7可移植性 279
13.4.8符合语言习惯 280
13.4.9良好地文档化 280
13.5如何设计代码 280
13.5.1设计方法和过程 281
13.5.2设计工具 282
13.6总结 285
13.7另请参见 285
13.8思考 286
13.8.1深入思考 286
13.8.2结合自己 287
第14章 软件体系结构：奠定软件设计的基础 288
14.1什么是软件体系结构 289
14.1.1软件蓝图 289
14.1.2视图 290
14.1.3在何时和何处进行体系结构设计 292
14.1.4用体系结构来做什么 293
14.1.5关于组件和连接 294
14.2什么是良好的体系结构 295
14.3体系结构风格 297
14.3.1没有体系结构 297
14.3.2分层的体系结构 298
14.3.3管道和过滤器体系结构 299
14.3.4客户端/服务器体系结构 299
14.3.5基于组件的体系结构 302
14.3.6框架 303
14.4总结 303
14.5另请参见 304
14.6思考 305
14.6.1深入思考 305
14.6.2结合自己 305
第15章 改良与革命：代码是如何成长的 307
15.1软件腐烂 308
15.2警告信号 310
15.3代码是如何成长的 312
15.4相信不可能之事 315
15.5对此我们可以做些什么？ 316
15.5.1编写新代码 316
15.5.2维护现有代码 317
15.6总结 319
15.7另请参见 319
15.8思考 320
15.8.1深入思考 321
15.8.2结合自己 321
第4篇 “一群”程序员 325
第16章 代码猴子：培养正确的编程态度和方法 325
16.1各种各样的猴子 326
16.1.1卖力工作的程序员 327
16.1.2代码猴子 328
16.1.3权威 329
16.1.4半权威 330
16.1.5傲慢的天才 331
16.1.6牛仔 333
16.1.7规划者 334
16.1.8老前辈 335
16.1.9狂热者 336
16.1.10单线条程序员 337
16.1.11拖沓者 338
16.1.12勉强的团队领导 339
16.1.13你 340
16.2理想的程序员 340
16.3那么该怎么办 341
16.4最愚蠢的人 342
16.5总结 343
16.6另请参见 343
16.7行为表格 344
16.8思考 345
16.8.1深入思考 345
16.8.2结合自己 345
第17章 团结就是力量：团队合作与个人程序员 347
17.1我们的团队——概览 348
17.2团队组织 350
17.2.1管理方法 350
17.2.2责任划分 350
17.2.3组织和代码结构 352
17.3团队合作工具 352
17.4团队疾病 354
17.4.1巴别塔 354
17.4.2独裁制 356
17.4.3民主制 357
17.4.4卫星站 359
17.4.5大峡谷 361
17.4.6流沙 363
17.4.7旅鼠 365
17.5良好团队合作的个人技巧和特点 366
17.5.1沟通 366
17.5.2谦虚 367
17.5.3处理冲突 367
17.5.4学习和适应能力 369
17.5.5了解你的不足之处 369
17.6团队合作原则 370
17.6.1集体代码所有制 370
17.6.2尊重别人的代码 371
17.6.3编码准则 371
17.6.4定义成功 371
17.6.5定义责任 372
17.6.6避免倦怠 372
17.7团队的生命周期 372
17.7.1团队的创建 373
17.7.2团队的成长 375
17.7.3团队合作 377
17.7.4团队结束 377
17.8总结 380
17.9另请参见 381
17.10行为表格 382
17.11思考 383
17.11.1深入思考 383
17.11.2结合自己 383
第18章 安全措施：源代码控制与自我控制 385
18.1我们的责任 386
18.2源代码控制 387
18.2.1修订控制 388
18.2.2访问控制 390
18.2.3处理代码库 390
18.2.4在代码树上创建分支 391
18.2.5源代码控制简史 393
18.3配置管理 393
18.4备份 395
18.5发布源代码 396
18.6应该将源代码放在哪里 397
18.7总结 398
18.8另请参见 399
18.9思考 400
18.9.1深入思考 400
18.9.2结合自己 400
第5篇 开发过程的组成部分 403
第19章 注意细节：编写软件规范 403
19.1规范到底是什么 404
19.2规范的类型 405
19.2.1需求规范 407
19.2.2功能规范 409
19.2.3系统体系结构规范 410
19.2.4用户界面规范 410
19.2.5设计规范 411
19.2.6测试规范 412
19.3规范应当包含哪些内容 413
19.4规范编写过程 415
19.5我们为什么会不编写规范 418
19.6总结 420
19.7另请参见 420
19.8思考 421
19.8.1深入思考 421
19.8.2结合自己 421
第20章 代码审查：执行代码审查 423
20.1什么是代码审查 424
20.2何时进行审查 425
20.2.1是否要进行审查 426
20.2.2审查哪些代码 427
20.3执行代码审查 427
20.3.1代码审查会议 428
20.3.2集成审查 431
20.4审查你的态度 432
20.4.1作者的态度 432
20.4.2审查人员的态度 433
20.5完美的代码 434
20.6代码审查之外 435
20.7总结 436
20.8另请参见 436
20.9清单 437
20.10思考 438
20.10.1深入思考 438
20.10.2结合自己 438
第21章 时间估计：软件时间范围估计的魔术 439
21.1在黑暗中摸索 440
21.2为什么估计这么困难 441
21.3压力之下 443
21.4实用的估计方法 444
21.5计划游戏 447
21.6坚持 451
21.7总结 454
21.8另请参见 454
21.9思考 455
21.9.1深入思考 455
21.9.2结合自己 455
第6篇 从高处鸟瞰 459
第22章 程序秘方：代码开发的方法和过程 459
22.1编程风格 460
22.1.1结构化编程 461
22.1.2面向对象的程序设计 462
22.1.3函数式编程 463
22.1.4逻辑编程 464
22.2烹饪方法：做什么与怎样做 464
22.3开发过程 465
22.3.1混乱 466
22.3.2瀑布模型 468
22.2.3 SSADM和PRINCE 470
22.3.4 V模型 470
22.3.5原型设计 471
22.3.6迭代和增量开发 472
22.3.7螺旋模型 473
22.3.8敏捷的方法 474
22.3.9其他开发过程 475
22.4已经够了 476
22.5选择一种过程 477
22.6总结 478
22.7另请参见 478
22.8思考 479
22.8.1深入思考 479
22.8.2结合自己 479
第23章 编程领域大观：不同的编程分支 481
23.1应用程序编程 482
23.1.1塑装软件 483
23.1.2定制应用程序 484
23.2游戏编程 485
23.3系统编程 486
23.4嵌入式编程 488
23.5分布式编程 490
23.6网络应用程序编程 492
23.7企业编程 494
23.8数字编程 495
23.9那又怎样 497
23.10总结 497
23.11另请参见 498
23.12思考 498
23.12.1深入思考 499
23.12.2结合自己 499
第24章 下一步呢：结果好就一切都好 500
但下一步该做什么呢？ 501
答案和讨论 504
参考书目 607