编程匠艺 编写卓越的代码2025|PDF|Epub|mobi|kindle电子书版本百度云盘下载

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

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

第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搜寻bug182

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递归地使用make215

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和PRINCE470

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