编程匠艺 编写卓越的代码PDF|Epub|txt|kindle电子书版本网盘下载

编程匠艺 编写卓越的代码PDF格式电子书版下载

注意：本站所有压缩包均有解压码： 点击下载压缩包解压工具

第Ⅰ篇　代码表面3

第1章　善于防守——健壮代码的防御性编程技巧3

1.1 向优秀的代码前进4

1.2　设想：最坏的选择4

1.3　什么是防御性编程6

1.4　又大又坏的世界8

1.5　防御性编程技巧8

1.5.1　使用好的编码风格和合理的设计9

1.5.2　不要仓促地编写代码9

1.5.3　不要相信任何人10

1.5.4　编码的目标是清晰，而不是简洁10

1.5.5 不要让任何人做他们不该做的修补工作11

1.5.6　编译时打开所有警告开关11

1.5.7　使用静态分析工具12

1.5.8　使用安全的数据结构12

1.5.9　检查所有的返回值13

1.5.10　审慎地处理内存（和其他宝贵的资源）13

1.5.11　在声明位置初始化所有变量14

1.5.12　尽可能推迟一些声明变量14

1.5.13　使用标准语言工具14

1.5.14　使用好的诊断信息日志工具15

1.5.15　审慎地进行强制转换15

1.5.16 细则15

1.6　约束16

1.6.1　约束的内容17

1.6.2　移除约束18

1.7　总结20

1.8　另请参见20

1.9　思考21

1.9.1 深入思考21

1.9.2　结合自己22

第2章　精心布局——源代码的版面和样式23

2.1　什么是关键24

2.2　了解你的读者25

2.3　什么是好的样式26

2.4　使用括号26

2.4.1 K＆R括号风格27

2.4.2　悬挂式的括号风格27

2.4.3　缩进的括号风格29

2.4.4　其他的括号风格29

2.5　主宰一切的风格30

2.6　内部风格（以及在哪里使用它们）31

2.7　设立标准33

2.8　正义的战争35

2.9　总结35

2.10　另请参见37

2.11　思考37

2.11.1　深入思考37

2.11.2　结合自己38

第3章　名正言顺——为有意义的事物起有意义的名称39

3.1 为什么我们应该恰当地命名呢41

3.2　我们对什么进行命名41

3.3　名字游戏42

3.3.1　描述性42

3.3.2　技术上正确42

3.3.3　符合语言习惯43

3.3.4　恰当43

3.4　具体细节44

3.4.1　命名变量44

3.4.2　命名函数45

3.4.3　命名类型46

3.4.4　命名名字空间47

3.4.5　命名宏48

3.4.6　命名文件48

3.5　玫瑰不叫玫瑰49

3.5.1　保持前后一致50

3.5.2　利用上下文51

3.5.3　使用对你有利的名称51

3.6　总结52

3.7　另请参见53

3.8　思考53

3.8.1 深入思考54

3.8.2　结合自己55

第4章　不言自明——编写“自文档化”代码的技巧57

4.1 自文档化的代码59

4.2　编写自文档化代码的技术61

4.2.1 使用好的样式编写简单的代码61

4.2.2　选择有意义的名称62

4.2.3　分解为原子函数62

4.2.4　选择描述性的类型63

4.2.5　命名常量63

4.2.6　强调重要的代码64

4.2.7　分组相关信息64

4.2.8　提供文件头64

4.2.9　恰当地处理错误65

4.2.10　编写有意义的注释65

4.3　实用的自文档化方法66

4.3.1 文学性编程66

4.3.2　文档化工具67

4.4　总结69

4.5　另请参见70

4.6　思考71

4.6.1　深入思考71

4.6.2　结合自己72

第5章　随篇注释——如何编写代码注释73

5.1　什么是代码注释74

5.2　注释看上去是什么样的75

5.3　多少注释是恰当的75

5.4　注释中应该有些什么76

5.4.1 解释为什么，而不是怎么样76

5.4.2　不要描述代码76

5.4.3　不要取代代码76

5.4.4　确保注释有用77

5.4.5　避免分心78

5.5 实践79

5.6　从审美的角度看注释80

5.6.1　一致性80

5.6.2　清晰的块注释80

5.6.3 缩进的注释81

5.6.4　行尾注释81

5.6.5　帮助你阅读代码81

5.6.6　选择一种维护成本较低的风格82

5.6.7　分隔板82

5.6.8　标志83

5.6.9　文件头注释83

5.7　使用注释84

5.7.1　帮助你编写例行程序84

5.7.2　错误修正通告85

5.7.3　注释过时85

5.7.4　维护和空洞无物的注释86

5.8 总结86

5.9　另请参见87

5.10　思考87

5.10.1 深入思考88

5.10.2　结合自己88

第6章　人非圣贤——处理不可避免的情况——代码中的错误情形89

6.1 从何而来90

6.2　错误报告机制91

6.2.1　不报告91

6.2.2　返回值92

6.2.3　错误状态变量93

6.2.4　异常93

6.2.5　信号95

6.3　检测错误95

6.4　处理错误96

6.4.1　何时处理错误97

6.4.2　可能的反应98

6.4.3　代码示例100

6.5　使地狱浮现104

6.6　管理错误105

6.7　总结106

6.8　另请参见107

6.9　思考107

6.9.1　深入思考107

6.9.2　结合自己108

第Ⅱ篇　代码的神秘生命111

第7章　欲善其事，先利其器——使用工具构建软件111

7.1　什么是软件工具112

7.2　为什么要在意工具114

7.3　使工具发挥作用115

7.3.1 了解它能做些什么115

7.3.2 学习如何驾驭它116

7.3.3 了解它适合什么任务116

7.3.4　检查它是否可用116

7.3.5　找到了解更多信息的途径117

7.3.6　查明新版本何时出现117

7.4　哪个工具117

7.4.1 源代码编辑工具118

7.4.2　代码构建工具120

7.4.3　调试和调查工具123

7.4.4　语言支持工具124

7.4.5　其他工具125

7.5　总结126

7.6　另请参见127

7.7　思考128

7.7.1 深入思考128

7.7.2　结合自己128

第8章　测试时代——测试代码的魔术129

8.1　反思现实131

8.2　谁、是什么、何时以及为什么132

8.2.1　我们为什么要测试132

8.2.2　谁来进行测试133

8.2.3　测试的内容有些什么133

8.2.4　何时进行测试134

8.3　测试并不难135

8.4　测试的类型138

8.5　选择单元测试用例142

8.6　为测试而设计144

8.7　看！不要用手！144

8.8　面对故障该怎么办145

8.9　你能管理它吗146

8.9.1　缺陷跟踪系统147

8.9.2　bug审查148

8.10　总结149

8.11　另请参见150

8.12　思考150

8.12.1 深入思考150

8.12.2　结合自己151

第9章　寻找缺陷——调试：当事情进展得不顺利时该怎么办153

9.1　生活的真相154

9.2　bug的种类155

9.2.1　从远处看155

9.2.2　从近处看156

9.2.3　从更近处看158

9.3 消灭害虫160

9.3.1　地下之路161

9.3.2　地上之路161

9.4　搜寻bug162

9.4.1　编译时错误162

9.4.2　运行时错误164

9.5　如何修正缺陷167

9.6　预防169

9.7　除蜂剂、驱虫剂、捕蝇纸169

9.7.1　调试器169

9.7.2 内存访问校验器170

9.7.3 系统调用跟踪170

9.7.4　内核转储170

9.7.5 日志170

9.8　总结171

9.9　另请参见172

9.10　思考173

9.10.1　深入思考173

9.10.2　结合自己173

第10章　代码构建——将源代码转换为可执行代码的过程175

10.1　语言障碍176

10.1.1　解释型语言177

10.1.2　编译型语言178

10.1.3　字节编译型语言179

10.2　小题大做179

10.3　构建软件版本181

10.4　怎样才算是一个优秀的构建系统184

10.4.1　简洁184

10.4.2　一致184

10.4.3　可重复和可靠185

10.4.4　原子性186

10.4.5　能够应付错误187

10.5　技术细节187

10.5.1　目标的选择187

10.5.2　内务处理189

10.5.3　依赖关系189

10.5.4　自动构建190

10.5.5　构建配置191

10.5.6　递归地使用make192

10.6　请发布我吧192

10.7　构建大师是全能的吗194

10.8　总结195

10.9　另请参见195

10.10　思考196

10.10.1　深入思考196

10.10.2　结合自己196

第11章　追求速度——优化程序和编写高效的代码199

11.1　优化是什么200

11.2　是什么使代码不尽如人意201

11.3　为什么不进行优化呢202

备选方案204

11.4　为什么要进行优化205

11.5　优化的具体细节206

11.5.1　证明你需要进行优化206

11.5.2　找出运行得最慢的代码207

11.5.3　测试代码208

11.5.4　优化代码209

11.5.5　优化之后209

11.6　优化的技术210

11.6.1　设计更改210

11.6.2　代码更改213

11.7　编写高效的代码217

11.8　总结219

11.9　另请参见219

11.10　思考220

11.10.1　深入思考220

11.10.2　结合自己221

第12章　不安全感综合症——编写安全的程序223

12.1　危险224

12.2　敌人226

12.3　借口，都是借口228

12.4　感到很脆弱229

12.4.1 不安全的设计和体系结构229

12.4.2　缓冲溢出229

12.4.3　嵌入的查询字符串230

12.4.4　竞争状况231

12.4.5　整数溢出231

12.5　防范措施232

12.5.1 系统安装技术233

12.5.2　软件设计技术234

12.5.3　代码实现技术235

12.5.4　规程技术236

12.6　总结236

12.7　另请参见237

12.8　思考238

12.8.1　深入思考238

12.8.2　结合自己238

第Ⅲ篇　代码的形成过程241

第13章　崇尚设计——如何创作出优秀的软件设计241

13.1　边设计边编程242

13.2　我们要设计什么243

13.3　为什么这么忙乱244

13.4 良好的软件设计245

13.4.1　简洁246

13.4.2　优雅247

13.4.3　模块化247

13.4.4 良好的接口248

13.4.5　可扩展性251

13.4.6　避免重复251

13.4.7　可移植性252

13.4.8　符合语言习惯252

13.4.9　良好地文档化253

13.5　如何设计代码253

13.5.1　设计方法和过程254

13.5.2　设计工具255

13.6　总结257

13.7　另请参见258

13.8　思考258

13.8.1　深入思考258

13.8.2　结合自己259

第14章　软件体系结构——奠定软件设计的基础261

14.1　什么是软件体系结构262

14.1.1　软件蓝图262

14.1.2　视图263

14.1.3　在何时和何处进行体系结构设计264

14.1.4　用体系结构来做什么265

14.1.5　关于组件和连接266

14.2　什么是良好的体系结构268

14.3　体系结构风格269

14.3.1　没有体系结构269

14.3.2　分层的体系结构270

14.3.3　管道和过滤器体系结构271

14.3.4　客户端／服务器体系结构271

14.3.5　基于组件的体系结构273

14.3.6　框架274

14.4　总结275

14.5　另请参见276

14.6　思考276

14.6.1　深入思考276

14.6.2　结合自己277

第15章　改良与革命——代码是如何成长的279

15.1　软件腐烂281

15.2　警告信号282

15.3　代码是如何成长的284

15.4　相信不可能之事286

15.5　对此我们可以做些什么287

15.5.1　编写新代码287

15.5.2　维护现有代码288

15.6　总结290

15.7　另请参见290

15.8　思考291

15.8.1　深入思考292

15.8.2　结合自己292

第Ⅳ篇　“一群”程序员295

第16章　代码猴子——培养正确的编程态度和方法295

16.1　各种各样的猴子296

16.1.1　卖力工作的程序员297

16.1.2　代码猴子298

16.1.3　权威299

16.1.4　半权威300

16.1.5　傲慢的天才300

16.1.6　牛仔302

16.1.7　规划者302

16.1.8　老前辈303

16.1.9　狂热者304

16.1.10　单线条程序员305

16.1.11　拖沓者306

16.1.12　勉强的团队领导306

16.1.13 你307

16.2　理想的程序员308

16.3　那么该怎么办308

16.4　最愚蠢的人309

16.5　总结310

16.6　另请参见310

16.7　行为表格311

16.8　思考312

16.8.1 深入思考312

16.8.2　结合自己312

第17章 团结就是力量——团队合作与个人程序员315

17.1　我们的团队——概览316

17.2　团队组织318

17.2.1 管理方法318

17.2.2　责任划分318

17.2.3　组织和代码结构320

17.3 团队合作工具320

17.4　团队疾病322

17.4.1 巴别塔322

17.4.2　独裁制324

17.4.3 民主制325

17.4.4　卫星站327

17.4.5　大峡谷329

17.4.6　流沙330

17.4.7　旅鼠332

17.5 良好团队合作的个人技巧和特点333

17.5.1 沟通333

17.5.2　谦虚334

17.5.3　处理冲突334

17.5.4 学习和适应能力335

17.5.5 了解你的不足之处336

17.6　团队合作原则336

17.6.1　集体代码所有制336

17.6.2　尊重别人的代码337

17.6.3　编码准则337

17.6.4　定义成功337

17.6.5　定义责任338

17.6.6　避免倦怠338

17.7　团队的生命周期339

17.7.1 团队的创建339

17.7.2　团队的成长341

17.7.3　团队合作342

17.7.4 团队结束343

17.8 总结345

17.9　另请参见346

17.10　行为表格347

17.11 思考348

17.11.1　深入思考348

17.11.2　结合自己348

第18章 安全措施——源代码控制与自我控制349

18.1　我们的责任350

18.2　源代码控制351

18.2.1　修订控制352

18.2.2　访问控制353

18.2.3　处理代码库354

18.2.4　在代码树上创建分支354

18.2.5 源代码控制简史356

18.3　配置管理356

18.4　备份358

18.5　发布源代码359

18.6　应该将源代码放在哪里360

18.7　总结361

18.8　另请参见362

18.9　思考363

18.9.1　深入思考363

18.9.2　结合自己363

第Ⅴ篇　开发过程的组成部分367

第19章　注意细节——编写软件规范367

19.1　规范到底是什么368

19.2　规范的类型369

19.2.1 需求规范371

19.2.2　功能规范373

19.2.3 系统体系结构规范373

19.2.4　用户界面规范374

19.2.5　设计规范374

19.2.6　测试规范375

19.3　规范应当包含哪些内容376

19.4　规范编写过程379

19.5　我们为什么会不编写规范381

19.6　总结383

19.7　另请参见383

19.8　思考384

19.8.1　深入思考384

19.8.2　结合自己384

第20章　代码审查——执行代码审查385

20.1　什么是代码审查386

20.2　何时进行审查387

20.2.1　是否要进行审查388

20.2.2　审查哪些代码389

20.3　执行代码审查389

20.3.1　代码审查会议390

20.3.2　集成审查392

20.4　审查你的态度393

20.4.1　作者的态度393

20.4.2　审查人员的态度394

20.5　完美的代码395

20.6　代码审查之外396

20.7　总结397

20.8　另请参见397

20.9　清单398

20.10　思考399

20.10.1　深入思考399

20.10.2　结合自己399

第21章 时间估计——软件时间范围估计的魔术401

21.1　在黑暗中摸索402

21.2　为什么估计这么困难？403

21.3　压力之下405

21.4　实用的估计方法406

21.5　计划游戏409

21.6　坚持！412

21.7　总结415

21.8　另请参见415

21.9　思考416

21.9.1　深入思考416

21.9.2　结合自己416

第Ⅵ篇　从高处鸟瞰419

第22章　程序秘方——代码开发的方法和过程419

22.1　编程风格420

22.1.1　结构化编程421

22.1.2　面向对象的程序设计422

22.1.3 函数式编程423

22.1.4　逻辑编程424

22.2　烹饪方法：做什么与怎样做424

22.3　开发过程425

22.3.1 混乱426

22.3.2　瀑布模型427

22.2.3 SSADM和PRINCE429

22.3.4　V模型430

22.3.5　原型设计430

22.3.6　迭代和增量开发432

22.3.7　螺旋模型432

22.3.8　敏捷的方法433

22.3.9　其他开发过程434

22.4 已经够了！435

22.5　选择一种过程436

22.6　总结437

22.7　另请参见438

22.8　思考438

22.8.1 深入思考438

22.8.2　结合自己439

第23章 编程领域大观——不同的编程分支441

23.1　应用程序编程442

23.1.1　塑装软件443

23.1.2　定制应用程序444

23.2　游戏编程445

23.3　系统编程446

23.4　嵌入式编程447

23.5　分布式编程450

23.6　网络应用程序编程451

23.7　企业编程453

23.8　数字编程454

23.9　那又怎样455

23.10　总结456

23.11　另请参见456

23.12　思考457

23.12.1　深入思考457

23.12.2　结合自己457

第24章　下一步呢——结果好就一切都好459

但下一步该做什么呢？460

答案和讨论463

参考书目559

索引564