文件类型：PDF/Adobe Acrobat 文件大小：字节
索 引
代码大全(第2版)
915
Ⅱ 中文索引
(符号/数字/字母)
&(指针引用符),332
*(指针声明符),332,334-335,763
->(指针符),328
0,除以0,292
80/20法则,592
Ada语言
参数顺序,174-175
介绍,63
ADT(Abstract Data Type),参见:
抽象数据类型
auto_ptrs,333
Basic语言,65;参见:Visual Basic
BCD(binary coded decimal,二进制
编码的十进制)类型,297
BDUF(Big Design Up Front,预先
做大量的设计),119
begin-end,742-743
break语句
while循环,379
带标号的(labeled),381
简化嵌套的if语句,446-447
一个循环中出现多次,380
在C++语言中退出循环,
371-372
指导建议,379-380
注意事项,381
Bug,参见:调试,代码中的缺陷,
错误
build工具,716-717;参见:编译器
C#语言,64
C++语言
DoNothing()宏,444-445
布尔表达式(boolean
expression)语法,442-443
参考资源,159
参数,按引用传递(by
reference)与按值传递(by
value),333
调试存根(debugging stubs),
208-209
断言(assertion)示例,191
副作用(side effects),759-761
宏(macro),182-184
接口(interface)所需的考虑
事项,139-141
介绍,64
空语句,444-445
命名约定,275-277
内联(inline)子程序,184-185
推荐的布局(layout),745
异常(exceptions),198-199
预处理器(preprocessors),排
除调试代码,207-208
源文件的布局(layout),773
指针(pointer),325,328-334,
763
CASE(Computer Assisted Software
Engineer,计算机辅助软件工程)
工具,710
case语句
default子句,363
按数字顺序排列,361
按执行频率(frequency of
execution)排列,361,
612-613
按字母顺序排列(alpha
ordering),361
编程语言的支持,361
表驱动法(table-driven
methods),421-422
重构(refactoring),566,573
重新设计(redesigning),453
错误检测,363
改用多态(polymorphism),
147-148
行尾布局(endline layout),
751-752
核对表,365
简化动作的指导建议(simple
action guideline),361
刻意制造的变量(phony
variables),361-362
末尾的case语句,363-365
调试,206
要点,366
与if语句的性能比较,614
越过(drop-through)case的
末尾,363-365
正常情况置先(normal case
first)原则,361
转换为嵌套的if语句,
448-449,451
组织各种情况(case)的顺序,
361
做相同的修改(parallel
modifications to),566
CMM(能力成熟度模型),491
Cobol语言,64
const关键字,C++中,176,177,
243,274,333
continue语句,379,380,381
CRC(类,职责,合作者)卡片,118
Currency(货币)数据类型,297
C语言
布尔表达式(boolean
expression)语法,442-443
抽象数据类型(ADT),131
介绍,64
命名约定(naming
conventions),275,278
指针(pointers),334-335
字符串(string)数据类型,
299-301,317
字符串索引(string index)错
误,299-300
Debug.Assert(断言调试)语句,
191-193
Decorator模式(Decorator pattern),104
Delphi示例,以汇编语言重写
(recoding to assembler),640-642
Demeter原则,150
diff工具,556,712
DoNothing()宏,444-445
do循环,369-370;参见:循环
DRY(Don't Repeat Yourself,不要重
复自己)原则,565
else子句
常见情况置先(common cases
first)原则,359-360
调用布尔函数(boolean
function)进行判断,359
判断链(chains),358-360
空语句(null statement),358
用case语句代替,360
用默认情况覆盖所有情况
(default for covering all
cases),360
与goto语句共用,406-407
正确性测试(correctness
testing),358
Exit Function语句,391;参见:return
语句
Exit Sub语句,392-393;参见:return
语句
Exit语句,参见:break语句
finally语句,404-405
final关键字,Java语言,243
foreach循环,367,372
Fortran语言,64
for循环
格式化(formatting),732-733,
索 引
代码大全(第2版)
916
746-747
目的,372
下标(index),377-378
优点,374
goto语句
比较若干替代方案,405
布局(layout)指导建议,
750-751
参考资源,409-410
重写代码的琐碎示例,
400-401
共享else子句中的代码,
406-407
合理使用,407-408
核对表,410
可读性问题(readability
issues),398
缺点,398-399
缩进问题(indentation
problem),398
未用到的标号(unused
labels),408
无谓的辩论(phony
debating),400-401
向前跳转(forward direction)
的指导建议,408
要点,410
用try-finally结构重写,
404-405
用嵌套的if语句重写,
402-403
用于错误处理,401-402
用于释放资源(deallocation),
399
用于消除重复代码,399
用状态变量(status variables)
重写,403-404
优点,399
优化问题(optimization
problem),398
在Ada语言中,399
在Fortran语言中,399
指导建议,407-408
grep工具,711
GUI(Graphic User Interface),
参见:图形用户界面
I/O(Input/Output),参见:输
入/输出
IDE(Integrated Development
Environment),参见:集成
开发环境
IEEE(电子与电器工程师协会),813
if语句
else子句,358-360,406-407
常见情况置先(common cases
first)原则,359-360
重构,573
从嵌套if语句的多处返回,
392-393
错误处理(error processing)
示例,356-357
单语句布局,748-749
颠倒顺序,358
调用布尔函数(boolean
expression)进行判断,359
覆盖所有情况,360
核对表,365
后续行,757
简单的(plain)if-then语句,
355-357
简化,445-447
将其中的否定(negative)判
断转换为肯定(positive)判
断,435-436
空的if子句,357
类型,355
嵌套,参见:嵌套的if语句
提取到子程序中,449-451
替代查询表(lookup table),
614-615
相等(equality)情况时的分
支(branching),355
要点,366
以频率(frequency)的顺序进
行判断,612-613
用break语句块简化,446-447
用表(table)替代,413-414
用其重写含有goto语句的代
码,402-403,406-407
与case语句的比较,360,614
语句串,358-360
正常路径置先(normal path
first)原则,355
正常情况置先(normal case
first)原则,356-357
转换为case语句,448-449,
451
转换为if-then-else语句,
447-448
in关键字,自行创建,175-176
Javadoc,807,815
JavaScript语言,65
Java语言
变量的持续性(persistence),
251
布尔表达式(boolean
expression)语法,443
布局(layout)建议,745
参考资源,159
参数(parameter)示例,
176-177
断言(assertion)示例,190
介绍,65
命名约定,276,277
生存时间(live time)示例,
247-248
异常(exception),198-201
JUnit,531
lint工具,557
Liskov替换原则(LSP),144-145
LSP(Liskov Substitution Principle),
参见:Liskov替换原则
Macintosh命名约定,275
McCabe的复杂度量度(complexity
metric),457,458
mock对象,523
null对象,重构,573
null语句,444-445
Observer(观察者)模式,104
Pareto法则,592
Perl语言,65
PHP语言(PHP: Hypertext Processor,
PHP:超文本处理器),65,600
Python语言
介绍,65
性能问题,600
return语句
参考资源,408
从子程序的多处返回,
391-393
防卫子句(guard clauses),
392-393
核对表,410
可读性(readability),391-392
要点,410
SCM(Software Configuration
Management,软件配置管理),
665;参见:配置管理
SDF(Software Development Folder,
软件开发文件夹),778
Set()子程序,576
sizeof(),335
strcpy(),301
strncpy(),301
struct关键字,参见:结构体
switch语句;参见:case语句
Tacoma Narrows大桥坍塌,74
try-finally语句,404-405
T型集成(T-Shaped integration),701
UDF(Unit Development Folder,单
元开发文件夹),778
UDT(User-Defined Type,用户自定
义类型)
缩写,279-280
UML(Unified Modeling Language,
统一建模语言)图(diagram),118,
120
Unicode,288-299
索 引
代码大全(第2版)
917
UNIX编程环境,720
Visual Basic语言
参考资源,159
参数(parameter)示例,180
大小写不敏感
(case-insensitivity),273
断言(assertion)示例,192-194
关闭隐式声明(implicit
declaration),240
结构体(structure),320-322
介绍,65
块风格(blocking style),738
枚举类型(enumeration type),
303-306
命名约定,278-279
推荐布局,745
异常(exception),198-199,
202
while循环
break语句,379
do-while循环,369
出口(exit),369-372
对判断(evaluation)的误解
(misconception),554
检测,所处位置,369
空语句,444
目的,368
无限循环(infinite loops),374
优势,374-375
Wiki(维基),117
WIMP(为什么Mary不在编程 !)
综合症,26
WISCA(为什么Sam不在写代
码 !)综合症,26
(A)
安全性,47
安装工具,718
(B)
白盒测试(whitebox testing),500,502
版本控制(version control)
工具,668,715
移除调试辅助代码,207
注释,811
绑定(binding)
编译时(compile time),
252-253
变量的绑定时间,252-254
代码中,252
即时(just in time),253
加载时(load time),253
启发式(heuristic)设计,107
要点,258
运行时(run time),253
包,156-157
包含(containment),88,143
报告,参见:正式检查
备份计划(backup plans),669,670
本地化
架构的前期准备,48
字符串数据类型,298
本质的问题(essential problems),
77-78
比较(comparisons)
布尔(boolean),参见:布尔
测试
浮点数等量判断(floating-point
equality),295-296
混杂的(mixed)数据类型,
293
边界值分析(boundary analysis),
513-514
编程的信仰态度(religious attitude)
布局风格成为信仰,735
管人,683-684
软件先知(software oracles),
851
与试验(experimentation)相
比,852-853
折中主义(eclecticism),
851-852
编程工具
build工具,716-717
diff工具,712
grep工具,711
merge工具,712
版本控制(version control)工
具,715
编辑器,710-713
编译器(compiler),716
参考资源,724
测试工具,719
尺度报告器,714
重构器(refactorer),714-715
打造自己的编程工具,
721-722
代码调整,720
代码库,717
代码生成向导,718
多个文件中查找字符串,
711-712
翻译器(translator),715
反汇编器(disassembler),720
工具导向的(tool-oriented)环
境,720-721
核对表,724-725
幻境(fantasyland),722-723
汇编代码清单生成(assembler
listing)工具,720
集成开发环境(IDE),710-711
计算机辅助软件工程(CASE)
工具,710
交叉引用(cross-reference)工
具,713
脚本(script),722
接口文档,713
结构改组(restructurer)工具,
715
可执行代码(executable-code)
工具,716-720
类的继承体系生成器(class
hierarchy generator),713
链接器(linker),716
美化器(beautifier),712
模板(template),713
目的,709
设计工具,710
数据字典(data dictionary),
715
调试工具,526-527,545,
558-559,719
图形化的设计工具,710
项目特有的工具,721-722
要点,725
依赖关系检查器(dependency
checker),716
语法(syntax)检查器,713-714
语义(semantic)检查器,
713-714
预处理器,718-719
源代码工具,710-715
执行剖测器(execution
profiler),720
质量分析,713-714
编程狂人(gonzo programming),832
编程方面的期刊(periodicals),
859-860
编程语言选择
Ada语言,63
Basic语言,6
C#语言,64
C++语言,64
Cobol语言,64
C语言,64
Fortran语言,64
JavaScript语言,65
Java语言,65
Perl语言,65
PHP语言,65
Python语言,65
SQL语言,65
Visual Basic语言,65
表达概念,63
高级语言与低级语言的生产
率,62
汇编语言,63
深入语言去编程(programming
索 引
代码大全(第2版)
918
into language),68-69,843
生产率来源,62
熟悉的语言与不熟悉的语言,
62
思维,影响,63
相对于C语言的等级,表格,
62
重要性,61-63
编程约定(convention)
编码实践的核对表,69
格式化规则,参见:布局
选择,66
编辑工具
diff工具,712
grep工具,711
merge工具,712
多个文件中查找字符串,
711-712
集成开发工具(IDE),710-711
交叉引用(cross-reference)工
具,713
接口文档(interface
documentation),713
类的继承体系生成器(class
hierarchy generator),713
美化器(beautifier),712
模板,713
编码(coding);参见:构建;软件
构建概述
风格(style);参见:布局
软件构建,5
实践核对表,69
序列式(sequential);参见:
直线代码
约定;参见:编码约定
编码的"写作隐喻(writing
metaphor)",13-14
编码约定(convention)
风险(hazard)规避,844
格式化(formatting);参见:
布局
好处,844-845
核对表,69
可预期的好处,844
编译器(compiler)
编译时绑定,252-253
在子程序中寻找错误,
230-231
把调试工具当作编译器,557,
827
多条出错信息,550
富于技巧的(tricky)代码优
化,597
工具,716
警告(warnings),293,557
破损的(broken)build,703
适合整个项目的标准,557
数据类型警告,293
信息,对待,549,826-827
行号,用以调试,549
性能调整的考虑,590
验证器,231
优化,596-597
优化的速度,表格,597
变更控制(change-control),参见:
配置管理
变量(variable)
绑定时间(binding time),
252-254
变化,标识区域,98-99
变量类型;参见:数据类型
持续性(persistence),251-252
重构,571,576
重用,255-257
初始化(initialization),
240-244,257
存活时间,246-248,459
迭代数据,255
公用类成员,576
混合耦合,256-257
计数器,243
就近原则,242
局部化引用,245
跨度,245
命名;参见:变量名
全局变量;参见:全局变量
声明变量;参见:声明
使用变量的核对表,257-258
使用所有已声明的变量,257
数据类型与控制结构之间的
关系,254-255
数据认知测试,238-239
序列型数据,254
选择型数据,254
循环变量,382-384
要点,258
隐含含义,避免,256-257
隐式声明,239-240
注释,803
作用域;参见:变量的作用域
变量的持续性(persistence),
251-252,831
变量的存活时间(lifetime),246-248,
459
变量的作用域(scope)
把相关语句放在一起,
249-250
变量跨度,245
变量名,影响,262-263
变量引用局部化,245
存活时间,最短化,246-248
定义,244
"方便性"论据,250
赋值,249
"可管理性"论据,251
全局作用域,问题,251
限制与扩展策略,250
循环初始化,249
要点,258
语言差异,244
最小化,指导原则,249-251
变量名
C++语言,263,275-277
C语言,275,278
Java命名规则,277
Visual Basic语言,279
保留的名字,287
布尔变量,268-269
长度,最适当的,262
常量,270
大小写,286
对仗词,264
多种自然语言,287
核对表,288-289
计算值限定词(computed-value
qualifiers),263-264
精确描述的原则,260-261
类成员变量,273
类型名,区分,272-273
良好的变量名,示例,260,
261
临时变量,267-268
枚举类型,269
名字的相似处,过多,285
命名空间(namespace),263
目的,240
拼错单词,286
全局,限定词,263
数字,286
缩写的指导原则,282
特征性原则,261
同音异义字,286
完全描述的原则,260-261
心理距离,556
信息分类,277
循环下标(loop index),265
要点,289
以问题为导向的原则,261
语音(phonic)缩写,283
"糟糕的变量名"示例,
259-260,261
状态变量,266-267
子程序名,区分,272
字符,易混淆,287
作用域,影响,262-263
变量名长度,最适当的,262
变量名的对仗,264
索 引
代码大全(第2版)
919
标记,缺陷,787
标志(flag)
goto语句,重写,403-404
变更,标明区域,98-99
枚举类型(enumerated type),
266-267
名称,266-267
语义耦合(semantic
coupling),102
注释标志位的含义(bit-level
meanings),803
标准,概述,814
表达式(expression)
布尔(boolean),参见:布尔
表达式
布局指导建议,749-750
常量,数据类型,635
初始化,编译时,632-633
公共表达式的消除
(subexpression
elimination),638-639
强度削减,630-632
系统调用的性能,633-634
右移(right shifting),634
预先计算的结果
(precomputing results),
635-638
表驱动法(table-driven method)
case语句法,421-422
保险费率示例,415-416
查询问题,412
从表达式创建,435
存放问题,413
代码调整,614-615
定义,411
对象法,422-423
二分查找(binary search),428
构造键值,423-424
核对表,429
键值,423-424
阶梯访问表,426-429
例子:灵活的消息格式,
416-423
目的,411-412
其他示例,429
区间的端点,428
设计方法,420
示例:一月中的天数,413-414
索引访问表,425-426,428-429
问题,412-413
要点,430
优点,420
预先计算某些运算,635
直接访问;参见:直接访问表
转换键值,424
别名(aliasing),311-316
不成熟的优化,840
不要重复自己(DRY,Don't Repeat
Yourself)原则,565
布尔变量(boolean variables)
C语言,创建数据类型,
302-303
标识符,431-433
表达式,参见:布尔表达式
核对表,317
简化判断,301-302
枚举类型作为替代方案,304
命名,268-269
文档,301
以0和1为值,432
布尔表达式(boolean expressions)
C语言语法,442-443
if语句中的否定,435-436
Java语法,439,443
把0和1作为值,432
比较时常量的位置,442-443
变量,参见:布尔变量
标识符,431-433
布局指导建议,749-750
拆分为多个部分判断,433
重构,572
狄摩根定理(DeMorgan's
Theorems)的应用,436-437
短路求值(short circuit
evaluation),438-440
否定,435-437
函数,移入,434-435
核对表,459
简化,433-435
决策表(decision tables),移
入,435
肯定(positive form)形式,
建议,435-437
括号用以明示,437-438
逻辑恒等式(logical
identities),630
求值的指导建议,438-440
数值,结构,440-441
隐式比较(implicit
comparisons),433
与0比较,441-442
指针,比较,441
字符,与0比较,441
布尔函数(boolean functions)
if语句,用于,359
从表达式创建,434-435
布尔判断(boolean tests)
拆分为多个部分判断,433
简化,301-302
用子程序隐藏,165
与0比较,441-442
布局(layout)
begin-end,742-743
begin-end两次缩进,746-747
C++中的副作用,759-761
goto,750-751
Visual Basic的块风格,738
不完整的语句,754-755
纯块风格(pure blocks style),
738-740
代码中的文档说明,763-766
单语句代码块,748-749
对特定语言的布局建议,745
风格概述,738
负面示例,730-731
复杂表达式,749-750
赋值语句后续部分,758
格式化的基本原理,732
行尾布局,743-745,751-752
核对表,773-774
花括号的布局风格,734,
740-743
会引起误导的缩进示例,
732-733
会引起误导的优先级计算顺
序,733
接口,768
结构风格,重要性,733-734
紧密关联的语句元素,
755-756
可读性目标,735
空白,732,736-737,753-754
空行,737,747-748
控制结构的布局风格,
745-752
控制语句的后续行,757
括号,738
类,768-771
论述的规矩,733
逻辑表达式,753
逻辑结构,展现,732,735
每行有多条语句,758-761
模仿纯块结构(emulating pure
blocks),740-743
目标,735-736
普通布局的示例,731-732
声明,761-763
始终如一的要求,735
数组引用,754
缩进(indentation),737
违背良好编程风格,注释,801
未缩进的begin-end对,746
文件,内部,771-773
信仰方面,735
修改建议,736
续行的结尾,756-757
要点,775
索 引
代码大全(第2版)
920
语句长度,753
语句的后续行,754-758
语句接续,754-758
语句块的布局风格,738-743
指针,C++,763
注释,763-766
资源,774-775
子程序的布局原则,766-768
子程序调用语句的后续行,
756
子程序实参(routine
argument),754
自说明代码(self-documenting
code),778-781
(C)
操作,常见操作的开销,601-603
操作系统,590
测试(test)
diff工具,524
JUnit,531
把错误的发生稳定下来,542
白盒(white-box)测试,500,
502
保留测试记录,529-530
笔误(拼写错误),519
边界检查工具,527
边界值分析,513-514
标准,IEEE,532
猜测错误,513
采用多种不同的方法,545
采用容易检查的测试用例,
516
测试本身的错误,522
测试数据生成器,524-525
测试先行或后行的建议,
503-504,531
测试先行开发(test-first
development),233
测试影响不到的特性,501
测试用例(test case),创建,
506-508,522-525,532
测试用例的错误,522
测试在软件质量中的角色,
500-502
从开发者角度测试的局限性,
504
"存在错误"假设,501
错误的分类,518-520
错误的影响范围,519
错误检查表,503
错误数据库,527
大多数错误都很容易修正,
519
代码覆盖,505-509,526
"代码覆盖"测试,506
单元(unit)测试,499,545
等价类划分(equivalence
partitioning),512
符号调试器,526-527
复合边界值,514
覆盖率优先级排序,505
干净测试的局限,504
工具,清单,719
构建范畴之外的错误,519
构建中测试,502-503
构建中的缺陷,比例,520-521
核对表,532
黑盒(black-box)测试,500
回归(regression)测试,500,
528
集成(integration)测试,499
几类好数据,515-516
几类坏数据,514-515
计划,528
脚手架(scaffolding),
523-524,531
结构化基础测试,503,
505-509
旧数据,兼容性,516
开发测试,522
开发者测试的局限性,504
可测试性,465,467
框架,522,524
乐观程序员的限制,504
量化,520,529
"逻辑覆盖"测试,506
模仿对象,527
目标,501
内存工具,527
期望的错误发生率,521-522
驱动函数(driver routine),523
惹人厌烦的特性,501
日志记录器,526
容易出错的类,517-518
设计,错误理解,519
设计要点,503
数据记录工具,526
数据流测试,509-512
随机数据生成器,525
调试,与测试对比,500
调试器,526-527
推荐方法,503-504
系统测试,500
系统干扰器,527
相关资源,530-531
需求,503
哑类(dummy classes),523
哑文件(dummy files),524
要点,533
"已定义-已使用"的数据路
径,510-512
用于测试的结果,502
占据的时间,501-502
正常情形的错误,515
正确性的可证明性,501,505
桩对象(stub object),523
子程序,黑盒测试,502
自动化测试,528-529
组件(component)测试,499
最大的正常局面,515
最小的正常局面,515
测试数据生成器,524-525
测试先行开发,233
策略模式,104
层次性设计目标,81
"差一"(off-by-one)错误
边界值分析(boundary
analysis),513-514
修改方法,553
忏悔式调试(confessional
debugging),547-548
常量(constants)
重构,571
初始化,243
定义,307
核对表,317
命名,270,273,277-279
模拟,309
目的,307
声明,308
一致性原则,309
由全局变量模拟,338
字面量,避免(literals,
avoiding with),308-309
超越函数,602,634
成熟的技术环境,67
诚实,826-828
程序规模,参见:项目规模
程序流
控制,参见:控制结构
序列式,参见:直线型代码
程序员,看待,参见:团队
分配时间,681
风格问题,683-684
概述,680
私密的办公室,684
物理环境,684-685
相关资源,685-686
信仰问题,683-684
性能差异,681-683
程序员,性格,参见:性格,个人
程序员所处的物理环境,684-685
程序组织的先决条件,45-46
持续集成(continuous integration),706
尺度报告器(metric reporter),714
索 引
代码大全(第2版)
921
重复(duplication)
避免,借助子程序,164-165
代码,作为重构指标,565
重构(refactoring)
80/20法则,582
case语句,573
DRY(不要重复自己)原则,
565
GUI(图形化用户界面)数据,
576
if语句,573
null对象,573
PPP(伪代码编程过程)编码
步骤,229
"安全重构"的指导建议,
579-581,584
把要做的事情一条条列出来,
580
备份老代码,579
变量,571
表达式,571
布尔表达式,572
参数,566,571,573
测试,580
策略,582-584
查询,574
代码调整,与重构作比,609
"代码重复"的指示,565
单向的类联系,577
单元测试,580
定义,565
对象,574-576
风险级别,581
复杂模块,583
工具,714-715
公用数据成员,567
构造函数改为工厂方法
(Factory Method),577
规模的指导建议,580
过多使用基本数据类型,567
核对表,570,577-579
基类,575
记录,572
检查,580-581
检查点,580
接口,566,575-576,579
警告信息,编译器,580
拒绝重构的理由,571
滥用,582
类,566-567,574-576,
578-579,582
类的数据类型,572
类接口,575-576
类内聚性的指示,566
流浪数据(tramp data),567
派生类,567,575
派生类间的不同常量,574
全局变量,568
缺陷,修补,582
群集,572
设计供将来某个时候用到的
代码,569-570
设置代码,568-569
收尾代码,568-569
数据级,571-572,577
数据设置,相对,指示,566
数组,572
双向的类联系,577
算法,573
条件表达式,573
"同一时间只做一项重构"原
则,580
无法控制来源的数据,576
系统级,576-577,579
相关资源,585
循环,565,573
要点,585
"要求多个相同修改"的指
示,566
易于出错的模块,582
引发的维护,583
引用对象,574
语句级,572-573,577-578
增加子程序,582
"中间人(middleman)"类,
567
重新设计而非重构,582
注释于拙劣代码,568
拙劣代码,接口,583-584
子程序,565-567,573-574,
578,582
字面形式表示的常量,571
重新测试,参见:回归测试
抽象(abstraction)
不好的类接口的示例,
134-135
不一致,135-136,138
层次,845-847
成对的操作,137
抽象数据类型;参见:抽象数
据类型
创建类接口的指导建议,
135-138
定义,89
访问器(accessor)子程序,
340-342
复杂度(complexity),839
高层问题域中的术语,847
好的类接口的示例,133-134
核对表,157
接口,抽象的目标,133-138
类,152,157
力求精确(exactness goal),
136-137
模式(pattern),103
内聚性(cohesion),138
评估,135
气锁阀(air lock)的比喻,136
实现结构,底层,846
问题域中的术语(problem
domain term),底层,846
形成一致的抽象,89-90
修改时破坏抽象,138
一致的类接口抽象层次,
135-136
在编程语言层次上
(programming-language
level),846
在操作系统的层次上,846
在继承树中的放置位置,146
子程序(routine),164
抽象工厂(Abstract Factory)模式,104
抽象数据类型(ADT)
把底层数据类型当成抽象数
据类型,130
把文件当成抽象数据类型,
130
操作示例表,129-130
抽象,130
代表什么的问题,130
定义,126
独立于存储介质,131
对象,130
多重实例的处理方法,
131-133
访问器子程序,339-342
改动不会扩散的好处,128
基于抽象数据类型的类,133
简单事物当作抽象数据类型,131
接口,提供更多信息,128
冷却系统的示例,129-130
目的,126
实例化,132
使数据传递最少,128
使用非面向对象语言,
131-133
数据的含义,126
文档的好处,128
显式地实例化,132
性能提升,128
需要抽象数据类型的例子,
126-127
验证代码的好处,128
益处,126-129
隐藏信息,127
隐式地实例化,132
真实世界中的实体(entities),
128-129
索 引
代码大全(第2版)
922
指导建议,130-131
出错信息(error messages)
代码,返回,195
设计,49
显示,196
友好出错信息的指导建议,
210
初始化变量
C++示例,241
Java示例,242-243
Visual Basic示例,241-242
编译器设置,243
不恰当初始化的后果,240
参数合法性,244
常量,243
重新初始化,243
第一次使用的建议,241-242
核对表,257
计数器,243
建议使用const,243
建议使用final,243
就近原则,242
类成员,243
累加器,243
全局变量,337
声明时的建议,241
系统干扰器,测试,527
修复缺陷,553
循环,其中用到的变量,249
要点,258
在靠近第一次使用变量的位
置声明和定义变量,
242-243
指针问题,241,244,325-326
重要性,240-241
字符串,300
初始化工作内存,244
除法(division),292-293
传递参数,333
创建out关键字,175-176
创造力的重要性,829,857
纯块布局风格,738-740
聪明,在性格中之角色,821
存根用来辅助调试,208-209
存根用来辅助集成,694,696
错误;参见:代码中的缺陷;异常
goto语句,用于处理,401-402
编码,参见:代码中的缺陷
处理,参见:错误处理
分类,518-520
根源,表,518
狗牌字段(dog tag fields),
326-327
异常;参见:异常
错误,猜测,513
错误处理,参见:异常
重构,577
传播(propagation)的设计,
49
错误处理子程序,调用,196
错误码,返回,195
断言(assertion),比较,191
返回中立值(neutral value),
194
防御式编程(defensive
programming),技术,
194-197
高层设计的影响,197
隔栏(barricades),203-205
关闭系统,196
缓冲区溢出(buffer overrun)
的威胁,196
记录警告信息,195
架构的前期准备,49-50
局部处理,196
可靠性(robustness),51,197
前次答案,重用,195
下一有效数据,返回,195
消息,49,195-196,210
验证设计,50
子程序,设计,222
最接近的合法值,195
错误检测,及早进行,29-30
错误码,195
(D)
大爆炸集成(big-bang integration),
691
大桥坍塌(bridge failure,Tacoma
Narrows),74
代码调整(code tuning)
80/20法则,592
DES示例,605-606
Pareto法则,592
比较逻辑结构,614
编译器方面的考虑,590,
596-597
表达式(expression),630-639
操作系统方面的考虑,590
测量以定位热点(hot spots),
603-604,644
查询表(lookup table),
614-615,635
常见操作的开销,601-603
乘法,改为加法,623-624
重构,比较,609
初始化,在编译时,632-633
从程序需求的角度看,589
代码中的缺陷(defect),601
代码行数,使之最少,593-594
代数恒等式(algebraic
identities),630
低级语言,重新编码为,
640-642
低效的根源,598-601
迭代(iteration),608,850
定义,591
短路求值(short-circuit
evaluation),610
惰性求值(lazy evaluation),
615-616
反汇编器,720
方法总结,606
分页(paging)操作,599
改进的可能性,605
概述,643-644
工具,720
功能细节,595
合并循环(jamming loops),
617-618
何时调整,596
核对表,607-608,642-643
缓存(caching)数据,628-629
汇编代码,列清单工具,720
汇编语言,重新编码为,
640-642
将判断外提后的循环
(unswitching loops),
616-617
解释型语言与编译型语言,
592,600-601
逻辑操作(logic manipulation)
的指导建议,610-616
内存操作还是文件操作,
598-599
内联子程序,639-640
频繁使用的代码,592
频率,作为测试顺序,612-613
嵌套循环的顺序,623
强度削减(strength
reduction),623-624,
630-632
缺点,591
哨兵测试(sentinel test),循
环,621-623
设计的视角看,589-590
使循环内的工作最少,
620-621
输入/输出,598-599
数据变换(data
transformations),624-629
数据库索引(indexing),601
数据类型的选择,635
数组(array),593-594,
603-604,625-627
诉求(appeal of),591-592
速度的重要性,595-596
随时随地优化,594-595
索 引
代码大全(第2版)
923
索引数据(indexing data),
627-628
无稽之谈(old wives' tales),
593-596
系统调用,599-600,633-634
消除公共子表达式
(subexpression
elimination),638-639
循环,616-624
循环展开,618-620
要点,608,645
硬件方面的考虑,591
优点,591
右移(right shifting),634
鱼和熊掌,595
语言细节,644
预先算出的结果,635-638
运算速度,假定,594
找出瓶颈,594
针对环境的变化进行调整,
594
整数优于浮点数,625
正确性的重要性,595-596
执行剖测器(execution
profiler)工具,720
转换数据类型,635
资源,606-607,644-645
资源目标(resource goals),
590
子程序,590,639-640
代码覆盖率测试(code coverage
testing),506
代码库(code libraries),222,717
代码生成向导(code-generation
wizards),718
代码阅读方法(code reading
method),494
代码质量分析工具,713-714
代数恒等式(algebraic identities),
630
单点控制,308
单件属性(singleton property),强制,
104,151
单进单出(FIFO,First-In First-Out)
的控制结构,454
单语句代码块,748-749
单元测试(unit testing),499
单元开发文件夹(UDF,Unit
Development Folder),778
等价类划分(equivalence
partitioning),512
狄摩根定理(DeMorgan's
Theorems),436-437
递归(recursion)
安全计数器,396
定义,393
核对表,410
留心栈空间,397
迷宫示例,394-396
排序示例,393-394
替代方案,398
停止递归,396
限制到一个子程序内,396
要点,410
用递归计算斐波纳契
(Fibonacci)数列,397-398
用递归计算阶乘,397-398
指导建议,394
迭代(iteration),代码,参见:循环
foreach循环,368,372
迭代器(Iterator)模式,104
迭代器循环,定义,367
迭代型数据,255
结构化编程的概念,456
迭代在开发中
代码调整,850
极限编程,58
前期准备,28,33-34
设计实践,111-117
伪代码成分,219
选择,理由,35-36
与序列式开发法的比较,
33-34
重要性,850-851
定义变量,参见:声明
定制,创建隐喻,18
度量(measurement)
反对的争论,678
副作用,678
目标,679
识别出"局外人(outlier)",
679
优点,677
有用度量类型的表格,
678-679
资源,679-680
短路求值(short-circuit evaluation),
438-440,610
断言(assertion)
C++示例,191
Java示例,190
Visual Basic示例,192-194
创建自己的机制,191
从代码中移除,190
错误处理,191,193-194
定义,189
后条件(postcondition)验证,
192-193
其中的可执行代码,191-192
前条件(precondition)验证,
192-193
实参(argument),189
危险的使用方法示例,192
依赖性(dependency),检查,
350
益处,189
应检查的假定,清单,190
与隔栏(barricade)的关系,
205
指导建议,191-193
中止程序,建议,206
资源,212
对代码签字(signing off on code),663
对数(logarithm),632-634
对系统的依赖性,85
对象(object)
protected接口,设计,89
包含,辨识,88
辨识,88
参数,用作,179,574
操作,辨识,88
重构,574-576
抽象数据类型(ADT),130
单件属性(singleton
property),强制,151
工厂方法(Factory Method)
模式,103-104,452-453,
577
公用成员与私用成员的比较,
设计,89
继承,辨识,88;参见:继承
接口,设计,89;参考:接口,
类
类,比较,86
类名,区分,272-273
删除对象,206
设计步骤,87-89
现实世界,寻找,87-89
引用对象,574
职责,分配,106
属性辨识,88
对象参数耦合,101
多个文件中查找字符串,711-712
多态(polymorphism)
case语句,替代,147-148
if嵌套,转换,452-453
定义,92
与具体语言相关的规则,156
多项式(polynomial expression),
631-632
多重继承(multiple inheritance),
148-149
惰性求值(lazy evaluation),615-616
(E)
二分查找(binary search),428
(F)
发展解决问题的技能,823
索 引
代码大全(第2版)
924
法律通告(legal notices),811
翻译器工具(translator tool),715
反汇编器(disassembler),720
方法(method),参见:子程序
方法论(methodology),657-659;
参见:开发方法
防御式编程(defensive
programming)
安全问题,212
产品代码(production code)
指导建议,209-210
错误处理,194-197
导致的问题,210
调制助手(debugging aids),
205-209
定义,187
断言(assertion),189-194
隔栏(barricade),203-205
核对表,211-212
检查假定(assumption),列表,
190
健壮性与正确性(robustness
vs. correctness),197
日志的指导建议,210
稳妥崩溃的指导建议,210
细微(trivial)错误的指导建
议,209
验证输入,188
要点,213
异常,198-203,211
硬性崩溃错误的指导建议,
209
友好提示消息的指导建议,
210
质量改善技术,其他,188
重要错误的指导建议,209
访问器子程序(accessor routine)
"g_"前缀,340
抽象的层次,341-342
抽象的好处,340
创建,340
当编程语言不支持时,克服,
340-342
隔离变量带来的好处,339
集中控制,339
锁定,341
信息隐藏的好处,340
要求,340
一致化(parallelism),342
优点,339-340
非标准的语言特性,98
非正式技术复查(informal review),
467,492-493
斐波纳契数列(Fibonacci numbers),
397-398
分层结构的(hierarchy)优点,
105-106
分而治之(divide and conquer)技术,
111
分解(factoring),154;参见:重构
分析技能的培养,823
分页操作,599
风格问题
格式化;参见:布局
人为因素,683-684
自说明代码,778-781
风险导向的集成,699
封装(encapsulation)
对用户的假定,141
公用数据成员,567
核对表,158
接口中的公用子程序,141
类,角色,139-143
类的公用成员,139
类的耦合太紧,142-143
类接口中的私用细节,
139-141
启发式设计(heuristic
design),90-91
让可访问性(accessibility)最
小,139
弱的封装,567
向下转型(downcast),对象,
574
友元类(friend class),141
语义上的破坏(semantic
violation),141-142
浮点(floating-point)数据类型
Visual Basic类型,297
二进制编码的十进制数
(BCD),297
核对表,316
精度限制,295
舍入误差(rounding errors),
297
数量级(magnitudes)相差巨
大的运算,295
相等比较(equality
comparisons),295-296
运算开销,602
符号调试器,526-527
复合边界值(compound boundaries),
514
复合语句(compound statements);
参见:语句块
复杂(complex)数据类型,参见:
结构
复杂度(complexity)
McCabe度量,457-458
编码约定,用以削减,839
抽象,处理,839
范围(span),459
隔离,借助类,153
管理,77-79,844-845
决策点(decision points),计
数,458
可靠性(reliability),457
控制结构对其的影响,
456-459
类,用以削减,152
模式,用以削减,103
生存期(live time),459
问题域(problem domain),工
作在,845
项目规模的影响,656-657
应对的方法,837-839
约定,以管理,844-845
智力实体数量的测算(mental
objects held,measure of),
457
重要性,457
子程序,用以削减,164
最小化的目标,80
复审(review)
代码阅读,494
迭代法(iteration),在复审中
的位置,850
非正式,定义,467
教育(educational)方面,482
公开演示(dog-and-pony
show),495
正式,质量,467
正式检查(formal inspection),
比较,485
重构后的检查,580-581
"逐行复审代码"原则,663
走查(walk-through),492-493
副作用(side effect),C++,759-761
赋值(assignment)语句,249,758
覆盖率(coverage)
监控(monitoring)工具,526
结构化基础测试(structured
basis testing),505-509
覆盖型链接器(overlay linker),716
(G)
改善代码执行速度的核对表,642-643;
参见:代码调整,性能调整
干扰器,参见:系统干扰器
高内聚性,105
高扇入(high fan-in)的设计目标,80
格式化代码(formatting code),参见:
布局
格式化的基本定理(Fundamental
Theorem of Formatting),732
隔栏(barricade)
接口作为边界,203
类层次,204
索 引
代码大全(第2版)
925
目的,203
手术室类比(analogy),204
输入数据的转换,204
与断言(assertion)的关系,
205
个人性格(personal character)
编译器信息,对待,826-827
成功的项目,从中学习,
823-824
诚实(intellectual honesty),
826-828
创造力(creativity),829,857
错误,承认,826
分析技能(analysis skills),823
疯狂编程(gonzo
programming),832
沟通技能(communication
skills),828
估计(estimations),827-828
好奇心(curiosity),822-825
合作技能(cooperation skills),
828
计算机科学系的毕业生,829
纪律(discipline),829
坚持(persistence),831
解决问题,823
经验,831-832
懒惰,830
弥补缺陷的手段,821
判断,848
谦卑,821,826,834
试验,822-823
习惯,833-834
要点,835
阅读,824
知晓开发过程,822
智力,821
重要性,819-820
专业开发(professional
development),824-825
状态报告,827
资源,834-835
宗教信仰,有害方面,851-853
个人性格,参见:性格,个人
耕作隐喻(farming metaphor),14-15
工厂方法(Factory Methods)
重构为,577
工厂方法(Factory Method)
模式,103-104
嵌套if语句,重构示例,
452-453
工具
编程;参见:编程工具
编辑;参见:编辑工具
核对表,70
调试;参见:调试
源代码;参见:源代码工具
工具的版本控制,668
工具箱法,20
公开演示(dog-and-pony shows),495
公用数据成员,567
功能导向的集成(feature-oriented
integration),700-701
功能的内聚性(functional cohesion),
168-169
功能规格书(functional
specification),参见:需求
沟通,开发团队,650
沟通技能的重要性,828
狗牌字段(dog tag fields),326-327
构建(construction),参见:软件构
建概览
各项活动的比例,按项目规
模,654-655
工具,参见:编程工具
管理,参见:管理构建
进度估计(schedules
estimating),参见:构建进
度表,评估
决策(decision),参见:构件
的决策
前期准备(prerequisites),参
见:前期准备
项目规模带来的影响;参见:
项目规模
协作(collaborative),参见:
协作
指导建议,66
质量,参见:软件的质量
资源,856
构建,每日,参见:每日构建,冒烟
测试
构建的决策(construction decisions)
编程语言,参见:编程语言的
选择
编程约定,66-66
编码实践核对表,69
成熟的技术环境,67
工具核对表,70
核对表,主要的构建实践,
69-70
技术浪潮,确定你在其中的位
置,66-69
浪潮早期的环境,67
深入语言编程(programming
into languages),68-69
团队合作核对表,69
要点,70
质量保证核对表,70
主要构建实践的选择,69-70
构建进度表,评估(construction
schedules,estimating)
比较多种技术,672
重新估计,672
方法列表,671
概述,671
赶上,675-676
计划估计时间,671
控制还是估计,675
乐观主义(optimism),675
确立目标,671
缩小范围,676
团队扩张,676
细致程度,672
需求规格(requirements
specification),672
影响因素,674-675
资源,677
构造函数(constructor)
重构,577
初始化数据成员,151
单体属性(singleton
property),确保,151
深拷贝与浅拷贝(deep vs.
shallow copies),151-152
异常,199
指导建议,151-152
购买组件(components),18,51
估计进度(estimating schedules)
变更的成本,666
不准确,性格原因,827-828
定期重新评估,672
多种技术比较,672
方法列表,671
概述,671
控制,比较,675
扩充团队,676
乐观主义(optimism),675
目标,确立,671
缩减范围,676
为评估时间制定计划,671
细致程度,672
需求规格(requirements
specification),672
影响因素,674-675
资源,677
关键构建决策,参见:构建决策
观察者(Observer)模式,104
管理构建
变更控制,参见:配置管理
标准,IEEE,687,814
标准,权威人士设定,662
程序员,对待态度,680-686
代码所有权的态度,663
度量,677-680
对代码签字,663
索 引
代码大全(第2版)
926
方法,参见:开发方法
复查所有代码,663
复杂度,77-79
奖励好的做法,664
进度,评估,671-677
经理,686
可读性的标准,664
良好编码实践,鼓励,662-664
两人组队,662
配置管理,参见:配置管理
详查,其中的经理角色,
486-487
项目规模,影响,参见:项目
规模
要点,688
资源,687
规格说明,参见:需求
国际化,48
过程,参见:子程序
何时采用,181-182
命名的指导原则,172
过程上的内聚性,170
过度工程,51
(H)
函数(functions),参见:子程序
不允许,150
定义,181
返回值,设置,182
何时使用,181-182
计算转换位函数,示例,
166-167
命名约定,172,181
私用(private),覆盖
(overriding),146
要点,186
状态作为返回值,181
行尾布局(endline layout),743-745,
751-752,767
行尾注释(endline comments),
793-795
好奇心,在性格中的角色,822-825
好数据,测试,515-516
合并(merge)工具,712
合并循环,617-618
合法性校验
对输入参数的原则,188
对外部数据源的原则,188
检查假定,清单,190
枚举类型,304-305
数据类型,质疑,188
合作技能(cooperation skills)的重
要性,828
核对表(checklists)
case语句,365
goto语句,410
if语句,365
备份,670
编程工具,724-725
编码实践,69
变量(variable),257-258,
288-289,343-344
表驱动法(table-driven
method),429
布尔表达式(boolean
expression),459
布局(layout),773-774
参数(parameter),185
测试(testing),503,532
常量(constant),317
抽象(abstraction),157
初始化(initialization),257
代码调整(code tuning),
607-608,642-643
调试(debugging),559-561
防御式编程(defensive
programming),211-212
封装(encapsulation),158
格式化(formatting),773-774
工具,70
构建实践(construction
practices),69-70
集成(integration),707
继承(inheritance),158
架构(architecture),54-55
接口(interface),579
结对编程(pair
programming),484
结构(structure),343
控制结构(control structure),
459,773,780
类(class),157-158,233-234,
578-579,774,780
类型(type)创建,318
枚举类型(enumerated type),
317
每日构建(daily build)与冒
烟测试(smoke test),707
名称,288-289,780
配置管理(configuration
management),669-670
前期准备(prerequisites),59
清单,xxix-xxx
缺陷(defect),489,559-560
设计(design),122-123,781
数据类型(data type),316-318
数据组织(data organization),780
数组(array),317
速度,调优,642-643
条件语句(conditional
statement),365
伪代码编程(pseudocoding),
233-234
文档(documentation),
780-781,816-817
性能调整,607-608
修复缺陷(defects),560
需求(requirements),40,42-43
循环(loop),388-389
语句(statement),774
正式检查(formal inspection),
489,491-492
直线(straight-line)代码,353
指针(pointer),344
质量保证(quality assurance),
42-43,70,476
重构(refactoring),570,
577-579,584
注释(comment),774,816-817
子程序(routine),185,774,
780
字符串(string),316-317
字符(character)数据类型,
316-317
黑盒测试(black-box testing),500
宏(macro)子程序,参见:子程序
多条语句,183
命名,183,277-278
使用括号,182-183
替代方案,184
限制,184
后条件(postcondition)
验证,192-193
子程序设计,221
后续行(continuation lines),754-758
互用性,48
花括号(braces)
风格比较,734
语句块布局,740-743
坏数据的检测,514-515
缓冲区溢出(buffer overrun),196
缓存(caching),代码调整,628-629
回归测试(regression test)
diff工具,524
定义,500
目的,528
汇编语言(assembly language)
介绍,63
清单工具,720
重新编码,640-642
混合耦合(hybrid coupling),变量的,
256-257
混合体,149
混合语言环境,276
(J)
基类(base class)
索 引
代码大全(第2版)
927
Liskov替换原则,144-145
protected的数据,143
抽象的可覆盖(overridable)
子程序,145
抽象方面,89
单一派生类,146
覆盖了却无所事事的子程序,
146-147
可覆盖与不可覆盖的
(overridable vs.
non-overridable)子程序,
145-146
耦合(coupling),太紧,143
基准测试,结构化的(basis testing,
structured),503,505-509
即时绑定(just in time binding),253
极限编程(Extreme Programming)
定义,58
缺陷检测,471-472
协作,482
资源,708,856
集成(integration)
T-型集成,701
测试,499,697
策略,概述,694
持续集成,706
垂直分块法,696
存根,694,696
错误,定位,693
大爆炸,691
定义,689
方法小结,702
分块法,698
风险导向的集成,699
功能导向的集成,700-701
核对表,707
集成方式的重要性,689-691
监控,693
阶段式,691-692
接口规格,695,697
进度,694
客户关系,694
类,691,694,697
冒烟测试,703
每日构建(daily build)与冒
烟测试(smoke test),
702-706
破损的生成结果(build),703
三明治策略,698-699
未浮出水面的工作,702
要点,708
益处,690-691,693-649
增量,参见:增量集成
资源,707-708
自下而上策略,697-698
自上而下策略,694-696
自上而下策略的缺点,
695-696
集成开发环境(IDE),710-711
集合(collection),重构,572
集体所有权(collective ownership),
482;参见:协作
计划(planning)
建筑隐喻,18-19
类比论据,27-28
论述数据,28-30
逻辑论据,27
软件项目的良好实践表,
31-32
计数循环(counted loops);参见:
循环
计算机辅助软件工程(CASE)工具,
710
记录,重构,572
记录设计成果,117-118
纪律(discipline)的重要性,829
技术浪潮,确定你在其中的位置,
66-69
继承(inheritance)
case语句,147-148
Liskov替换原则,144-145
并行修改作为重构指标,566
定义,144
多重继承,148-149
覆盖的子程序没做任何操作,
146-147
过深的继承体系,147
函数,私用,覆盖,146
核对表,158
混合体,149
继承到访问权限,148
将共用项放在继承树中,146
将继承看作设计的一步,88
敬而远之,149
可覆盖与不可覆盖子程序的
比较,145-146
启发式设计,91-92
设计规则,144
涉及的决策,144
"是一个……"关系,144
私用,避免,143
私用数据与受保护数据之对
比,148
相似的派生类和基类,576
要点,160
与包含关系的比较,143
只有一个派生类,146
指导建议,清单,149
主要目标,136
加法的危险,295
加载时,绑定,253
架构(architecture)
安全性(security)设计,47
本地化(localization)规划,
48
变更,44,52
程序组织(program
organization),45-46
错误处理,49-50
定义,43
风险领域(risky area),明确,
53
复用的决策(reuse decisions),
52
概念完整性,52
构造块(building block)的定
义,45
国际化(internationalization)
规划,48
过度工程(overengineering),
51
核对表,54-55
互用性(interoperability),48
机器无关性(machine
independence),53
技术可行性(feasibility),51
开发相关资源,57
可伸缩性(scalability),48
类的设计,46
买(buying)组件还是造
(building)组件,51
前期准备,44
容错(fault tolerance),50
输入/输出(input/output),49
数据设计,46
所占百分比,按项目规模,
654-655
图形用户界面(GUI),47
性能导向(performance-
oriented),590
性能目标,48
延迟提交的策略(commitment
delay strategy),52
验证设计,50
要点,60
业务规则(business rules),46
用户界面设计,47
允许耗时,56
质量(quality),52-53,55
重要性,44
资源管理,47
减法,295
简单对象耦合,101
简单数据参数耦合,101
建模,隐喻.参见:隐喻,软件
建筑隐喻(building metaphor),16-19
健壮性
定义,197,464
索 引
代码大全(第2版)
928
架构的前期准备,51
用断言处理错误,193-194
正确性,权衡,197
将循环的判断外提,616-617
交叉引用工具(cross-reference
tools),713
脚本
编程工具,772
运行缓慢,600-601
脚手架
测试,523-524,531
调试,558
阶乘(factorials),397-398
阶段式集成,691-692
阶梯访问表,426-429
接口,类(interface, class)
不良抽象示例,134-135
不相关的信息,处理,137
布局,768
抽象层次不一致,示例,
135-136
抽象方面,89,133-138,566
创建的建议,135-138
从语义上破坏封装性,
141-142
调用类,重构,575
对象,设计,89
反操作,成对,137
混合体,149
集成,期间的接口规格说明,
695,697
接口中的公用子程序,141
可编程优于语义,137
扩展类,用以重构,576
良好抽象的示例,133-134
内聚性,138
评估抽象性,135
让阅读时更便利的原则,141
私用的实现细节,139-141
外部子程序,用其重构,576
委托与继承,重构,576
文档化,713,810
信息隐藏的任务,93
修改时破坏接口抽象性,138
严格描述类契约,106
要点,160
一致的抽象层次,135-136
移入子程序重构法,575
与接口抽象不一致的成员,
138
重构,575-576,579
子程序,未使用的,576
接口,子程序,参见:子程序的参数
公用的成员变量,576
外部子程序,用以重构,576
伪代码,226
移入子程序重构法,575
注释,808
子程序,隐藏,576
结对编程
编码规范,提供支持,483
步伐,跟上,483
定义,483
个人性格冲突,484
好处,484
何时不用结对编程,483
核对表,484
轮换结对人员的工作,483
旁观,483
显示器的可见性,484
新手结对,484
要点,497
与其它协作形式相比,
495-496
资源,496
组长,484
结构化编程
迭代,456
概述,454
顺序,454
选择,455
中心论点,456
结构化查询语言(SQL),65
结构化基础测试
理论,505-509
推荐,503
结构体
Visual Basic示例,320-322
定义,319
非结构化数据示例,320
过度使用,322
核对表,343
减少维护,323
交换数据,321-322
类当作结构体,319
明确数据关系,320
使用结构体调用子程序,322
使用结构体简化参数列表,
322
使用结构体简化数据操作,
320-322
数据关系,关系清晰的示例,
320
数据块,操作,320-322
要点,344
结构重组工具,715
解释型语言,性能,600-601
界面,图形,参见"图形化用户界面
(GUI)"
进度,估算.参见:估算进度
进攻式编程,206
经验,个人的,831-832
精简性设计目标,81
精确性(accuracy),464
警告标志,848-850
净室开发(cleanroom development),
521
就近原则,242,351
矩阵,参见:数组
具名常量,参见:常量
决策表(decision table),参见:表
驱动法
(K)
开发标准,IEEE,813
开发方法
不成熟的优化的问题,840
迭代式(iterative)方法;参
见:开发过程中的迭代
极限编程(Extreme
Programming),58,
471-472,482,708,856
敏捷开发(agile
development),58,658
团队过程(team processes),
839-840
序列式(sequential)方法,
35-36
质量控制(quality control),
840;参见:软件的质量
重要性,839-841
资源,58-59
自上向下(top-down)的方法,
111-113,694-696
自下而上(bottom-up)的方法,
112-113,697-698
开发过程(development processes),
参见:开发方法
开发者测试(developer testing),参
见:测试
开销(costs),参见:性能调整
变更的估计,666
调试,消耗的时间,474-475
估计,658,828
检测缺陷(defect),472
结对编程还是详查(pair
programming vs.
inspections),480-481
缺陷,519-520
软件质量的普遍规律(General
Principle of Software
Quality),474-475,522
协作的好处,480-481
修复缺陷,472-473,519
易错的(error-prone)子程序,
518
资源,658
科学的方法,经典步骤,540
索 引
代码大全(第2版)
929
可测试性(testability)
策略,467
定义,465
可读性(readability)
暴露出缺乏可读性的缺陷,
538
带来的维护好处,842
当作管理标准,664
定义,464
基于可读性而格式化,参见:
布局
基于可读性而命名变量,参
见:命名规则,变量命名
将可读性当作警告信号,849
结构,重要性,733-734
私用程序与公用程序的比较,
842
正面影响,841
重要性,13,841-843
专业开发,重要性,825
可覆盖的子程序,145-146,156
可见性(visibility);参考:变量的
作用域
类,93
耦合标准,100
可靠性(reliability)
定义,464
内聚性子程序,168
可扩展性(extensibility)的设计目标,
80
可理解性,465;参见:可读性
可伸缩性,48;参见:项目规模
可移植性(portability)
定义,464
数据类型,定义数据类型以便
移植,315-316
子程序,165
可用性(usability),463
可执行码工具(executable-code
tools)
build工具,716-717
安装(installation)工具,718
安装(setup)工具,718
编译器(compiler),参见:编
译器
代码库(code libraries),717
代码生成向导
(code-generation wizards),
718
链接器(linker),716
预处理器(preprocessor),
718-719
可重用性(reusability)
定义,464
架构的前期准备,52
空(null)对象,重构,573
空白
单条语句,753-754
定义,732
分组,737
空行,737,747-748
缩进,737
重要性,736
空行,用作格式化,747-748,765-766
控制结构(control structure)
case语句,参见:case语句
goto语句,参见:goto语句
if语句,参见:if语句
不常用的,概述,408
布尔表达式(boolean
expressions),参见:布尔表
达式
布局风格(layout style),
745-752
递归(recursive),参见:递归
迭代(iteration),255,456
返回,参见:return语句
复合语句(compound
statements),443
复杂度(complexity),456-459
核对表,459,773,780
后续行(continuation lines),
757
结构化编程(structured
programming),454-455
可靠性与复杂度
(complexity),457
空语句(null statements),
444-445
两次缩进begin-end对,
746-747
数据类型的关系,254-255
条件流程(conditional flow),
参见:条件语句
未缩进的begin-end对,746
文档(documentation),780
序列型数据(sequential data),
254
选择型数据(selective data),
254
循环(loop),参见:循环
要点,460
注解(commenting),804-805,
817
子程序多处返回,391-393
库,代码
目的,717
使用其中的功能,222
跨度,245,459
括号
布局,738
对称技巧,437-438
(L)
懒惰,830
浪潮的前期环境(early-wave
environments),67
老板就绪测试,对前期准备(boss
readiness test on prerequisites),
30-31
类(class)
case语句与继承,147-148
Liskov替换原则,144-145
PPP的替代,232-233
private成员,150
private数据与protected数据,
148
protected数据,148
public成员,139,141,576
Set()子程序,不必要的,576
包(package),155-157
包含(containment),143-144
编码子程序,从伪代码
(pseudocode),225-229
变更,153
并行修改(parallel
modifications),重构指标,
566
不相关的类,155
布局,768-771
参数传递,顺畅
(streamlining),153
测试先行开发(test-first
development),233
常量值,返回,574
成员变量(member variables),
命名,273,279
成员数目,143
抽象,核对表,157
抽象对象,建模,152
抽象数据类型(abstract data
type),参见:抽象数据类
型
初始化成员,243
创建的步骤,216-217
创建的理由,152-156
单体属性(singleton
property),确保,151
单向关联(unidirectional
association),577
单一实例(single-instance),
146
调用,重构,575
定义,125
对象,对比,86
对象名称,区别,272-273
对用户的假定(assumption),
141
方法(method),参见:子程
索 引
代码大全(第2版)
930
序
分解(factoring)的好处,154
封装(encapsulation),
139-143,158
复杂度(complexity)问题,
152-153
覆盖(overriding)子程序,
145-146,156
格式化(formatting),768-771
构造函数(constructor),
151-152
规定接口契约(contract),106
过程(procedure),参见:子
程序
过度格式化(overformatting),
770
函数(function),参见:函数,
子程序
核对表,157-158,774,780
混合体(mixins),149
基类(base),参见:基类
基类(superclasse),为共有代
码(common code),575
集成(integration),691,694,
697
集中控制,153
继承(inheritance),144-149,
158
架构的前期准备,46
间接调用其他类,150
建模真实世界的对象,152
禁止函数与操作符,150
警告标记(warning sign),
848,849
可复用性(reusability)的好
处,154
可见性(visibility),93
扩充(extension),重构,576
命名,277,278
内聚性(cohesion),作为重构
指标,566
耦合(coupling)方面的考虑,
100-102,142-143
派生类(subclass),165,575
派生类(descendant),重构的
指标,567
拼凑(hacking)法,233
评审(review)与测试(test)
的步骤,217
全局数据(global data),隐藏,
153
让阅读时更方便(read-time
convenience)的法则,141
设计,86,216,220-225,233
深继承树(deep inheritance
tree),147
实现(implementation)的核
对表,158
"是一个(is a)……"的关
系,144
双向联系(bidirectional
association),577
外部(foreign)子程序,重构,
576
万能(god)类,155
为程序族(program families)
做计划,154
伪代码(pseudocode),为设
计,232-234
委托还是继承(delegation vs.
inheritance),重构,576
文档,780,810
文件,771-772
无数据(data-free),155
限制合作(collaboration),150
相似的基类与派生类,576
信息隐藏(information
hiding),92-93
要点,160,234
一个文件多个类,布局,
769-770
隐藏实现细节,153
用存根对象(stub object)测
试,523
友元(friend class),涉及违反
封装(encapsulation
violation),141
语义上破坏封装(semantic
violations of
encapsulation),141-142
针对特定语言的问题,156
重构(refactoring),155,
574-576,578-579,582
资源,159
子程序,参见:子程序
子程序,未使用的,146-147,
576
子程序构建的步骤,217
子程序数目,150
最小化可访问性
(accessibility)原则,139
类,职责,合作者(CRC,
Class-Responsibility-Collaborator)
卡片,118
类的继承体系生成器
(class-hierarchy generators),713
类型创建
C++,312
Pascal示例,312-313
合法性校验的好处,314
核对表,318
集中化的好处,314
可靠性的好处,314
可移植性的好处,315-316
类,与类型作比,316
命名规则,315
目的,311-312
示例,313-315
所用语言,评价,314-315
信息隐藏,313-314
易于修改的好处,314
预定义类型,避免,315
原因,314
指导原则,315-316
重定义一个预定义的类型,
315
类型定义,278
链表
插入节点,327-329
删除指针,330
指针,隔离操作,325
链接器,716
了无章法的过程(sloppy process),
75-76
临时变量,267-268
临时的内聚性,169
灵活性(flexibility)
定义(defined),464
耦合标准化(coupling criteria
for),100-101
流,206
流程,开发,参见:开发方法
论述之规矩(discourse rules),733
逻辑表达式,参见:布尔表达式
布局,753
查询表,替代,614-615
代码调整,610-616
短路求值,610
惰性求值,615-616
恒等式,630
频率,以出现频率调整判断顺
序,612-613
消除冗余测试,610-611
性能比较,614
逻辑覆盖率测试,506
逻辑内聚性,170
(M)
买组件还是造组件(building vs.
buying components),18
蛮力调试(brute-force debugging),
548-549
冒烟测试,703
枚举类型(enumerated type)
C++,303-304,306
Java语言中,创建,307
Visual Basic语言,303-306
变更的好处,304
索 引
代码大全(第2版)
931
遍历,305
标准,306
布尔类型,替代,304
参数,303
创建,为Java,307
定义,303
好处,303
核对表,317
可读性(readability),303
可靠性(reliability)的好处,
304
可用的语言,303
明确赋值(explicit value)的
缺点,306
命名,269,274,277-279
首项无效(first entry invalid)
技巧,305-306
循环限制,305
验证,304-305
用全局变量模拟,338
用注释代替,802-803
每日构建(daily build)和冒烟测试
(smoke tests)
build小组,704
定义,702
好处,702
核对表,707
冒烟测试(smoke tests),703
破损的生成结果(broken
builds),703,705
未浮出水面的工作
(unsurfaced work),702
修订版本(revisions),704
压力(pressure),706
预先测试,要求(pretest,
requirement),704
暂存候补区(holding area for
additions),704-705
早上发布(morning releases),
705
诊断(diagnosis)的好处,702
重要性,706
自动化,704
美感(beauty),80
面向对象的编程(object-oriented
programming)
对象,参见:类,对象
多态,参见:多态
继承,参见:继承
相关资源,119,159
隐藏信息,参见:信息隐藏
敏捷开发(agile development),58,658
名称的缩写,283-285
名字的语音缩写,283
命名规则(naming convention)
a前缀的命名规则,272
C++,275-277
C语言,275,278
Java,276,277
Macintosh,275
"t_"前缀的命名规则,272
Visual Basic,278-279
保留名,287
变量命名,参见"变量名"
标准前缀,279-281
参数,178
长度,不限制,171
常量,273-274
常用操作,172-173
辞典,使用,283
大小写,274,286
大小写不敏感的语言,273
短变量名,282-285,288-289
对仗,使用,172
多种自然语言,287
发音指导原则,283
非正式,272-279
分隔符,274
关系,强调,271
过程描述,172
函数返回值,172
好处,270-271
何时采用,271
核对表,288-289,780
混合语言的注意事项,276
减少命名增生的好处,270
仅通过数字区分,171
可读性,274
跨项目方面的好处,270
类成员变量,273
类名与对象名,272-273
令人误解的名字,285
枚举类型,269,274,277-279
描述性的指导原则,171
名字包含的信息种类,277
名字的相似处,过多,285
命名含义,太相似,285
目的,270-271
拼错单词,286
全局变量,273,342
输入参数,274
数据类型与变量名,272-273
数字,286
数组,280-281
缩写的指导原则,282
缩写名称,282-285
同音异义字,286
文档说明,284-285,778-780
文件,811
匈牙利命名法,279
要点,289
用户自定义类型(UDT)缩写,
279-280
与语言无关的指导原则,
272-274
语义前缀,280-281
语音缩写,283
正式程度,271
子程序,171-173,222
字符,易混淆,287
模板方法模式,104
模板工具,713
模仿的纯块布局风格(emulated pure
blocks layout style),740-743
模块,耦合的注意事项,100-102
模块化
全局变量,对模块化的害处,
337-338
设计目标,107
模式(pattern)
表格,104
工厂方法(Factory Method),
103-104
减少出错的好处,103
减少复杂度,103
建议的替代模式,103
交流方面的好处,104
缺点,105
相关资源,120
益处,103-104
牡蛎养殖隐喻,15-16
目标,软件质量,466,468-469
目录
表,xxxi-xxxii
核对表,xxix-xxx
图,xxxiii-xxxvii
(N)
内存(memory)
初始化工作内存,244
分配,错误检测,206
分页操作对内存性能的影响,
599
工具,527
破坏,指针造成,325
填充工具,244
指针,造成的内存破坏,325
内聚(cohesion)
接口,类,138
强度削减(strength
reduction),623-624,
630-632
巧合的内聚性(coincidental
cohesion),170
子程序,设计,168-171
内联子程序(inline routine),184-185
索 引
代码大全(第2版)
932
能够随时扔掉的代码,114
能力成熟度模型(CMM,Capability
Maturity Model),491
(O)
偶然(次要)的问题(accidental
problems),77-78
耦合(coupling)
大小,100
对象参数类型(object-
parameter type),101
基类与派生类之间的,143
简单对象类型,101
简单数据参数类型
(simple-data-parameter
type),101
可见性(visibility),100
类,太紧,142-143
灵活性(flexibility),100-101
目标,100
设计方面的考虑,100-102
松散(loose),80,100-102
语义类型(semantic type),102
(P)
排序,递归算法,393-394
"抛弃一个"之隐喻,13-14
培植系统,隐喻(growing a system
metaphor),14-15
配置管理(configuration
management)
SCM(Software Configuration
Management),665
版本控制(version-control)软
件,668
备份计划,669,670
变更控制委员会(change-
control boards),667
标明变更区域,97-99
成本,估计,666
成组处理变更请求,666
大量变更,666
代码改动,667-668
定义,664
估计变更成本,666
官僚主义(bureaucratic)方面
的考虑,667
核对表,669-670
机器配置(machine
configurations),重现
(reproducing),668
架构预料变更(architectural
anticipation of change),52
目的,664-665
设计变更,666-667
需求变更,41,664,666-667
资源(resources on),670
拼凑式设计(hacking approach to
design),233
(Q)
启发式方法(heuristics)
错误猜测,513
设计,参见:启发式设计
与算法(algorithm)比较,12
启发式设计(heuristic design)
绑定时间(binding time)方 面
的考虑,107
避免失败,106-107
变更,标明区域,97-99
测试,预料,106
抽象,形成一致的,89-90
迭代实践(iteration practice),
111-117
对象,真实世界,寻找,87-89
非确定性(nondeterministic),
87
分层结构(hierarchies),
105-106
分而治之(divide and conquer)
技术,111
封装(encapsulation),90-91
规则总结,108
核对表,122-123
画图,107
记录工作,117-118
继承(inheritance),91-92
建议多种方法,110
接口,用契约(contracts)严
格描述,106
蛮力(brute force),107
面向对象(object-oriented)相
关的资源,119
模块化(modularity),107
模式(pattern),103-105,120
模式的替代方案,103
模式在沟通方面的好处,104
目标,核对表,122-123
耦合方面的考虑,100-102
强内聚(strong cohesion),105
设计过程的本质,76
实践,110-118,122
完备度(completion),确定,
115-117
详细程度(level of detail),所
需的,115-117
协作(collaboration),115
信息隐藏(information
hiding),92-97,120
严格描述类的契约(class
contracts),106
要点,123
用模式减少错误,103
原型(prototyping),114-115
责任(responsibilities),赋予
对象,106
正式程度(formality),确定,
115-117
指导建议,109-110
中心控制点,107
资源,121
自下而上设计法,112-113
自上而下设计法,111-112,
113
谦卑(humility)在性格中的角色,
821,826,834
前期准备,前期
WIMP综合症(为什么Mary
不在编程 !),26
WISCA综合症(为什么Sam
不在写代码 !),26
不周全的准备,诱因,25-27
成功需要的技能,25
错误检测,及早进行,29-30
迭代式开发法,28,33-34
"管理者无知"的问题,26
"过早编码"之错误,25
核对表,59
混合使用序列式开发法和迭
代式开发法,34-35
架构,参见:架构
老板就绪测试,30-31
类比论据,27-28
逻辑论据,27
目标,25
目标是降低风险,25
软件项目的良好实践表,
31-32
数据论述,28-30
问题定义,36-38
项目种类,31-33
需求开发,参见:需求
要点,59-60
有力论据,27-31
允许的时间,55-56
在序列式开发法和迭代式开
发法之间做出选择,35-36
重要性,24
前期准备,参见:前期准备,前期
前条件
验证,192-193
子程序设计,221
前缀,标准化,279-281
嵌入式,性命攸关的系统(embedded
life-critical systems),31-32
嵌套的if语句
过多的嵌套层次,445-454
将其按功能分解(functional
索 引
代码大全(第2版)
933
decomposition),450-451
提取到子程序中,449-451
用break语句块简化之,
446-447
用于减少嵌套的技术的总结,
453-454
重新测试条件(retesting
conditions)使之简化,
445-446
重新设计,453
转换为case语句,448-449,
451
转换为if-then-else语句,
447-448
转换为采用工厂方法(Factory
Method)模式的方法,
452-453
转换为采用面向对象
(object-oriented)的方法,
452-453
嵌套循环
出于性能考虑的循环次序,
623
设计,382-383,385
强度,参见:内聚性
强制类型转换,避免,334
桥接(Bridge)模式,104
全局变量(global variables)
"g_"前缀原则,340
别名问题(aliasing problems),
336-337
持久性(persistence),251
初始化(initialization)问题,
337
大型对象,343
代码复用(code reuse)问题,
337
代码重入(re-entrant code)问
题,337
访问器子程序,参见:访问器
子程序
改变,无意中的,336
概述,335-336
核对表,343-344
降低风险的策略,342-343
局部变量优先的指导建议,
339
具名常量,模拟,338
类变量,替代方案,339
流浪数据,消除,338
命名,263,273,277,278,
279,342
模块化(modularity),破坏,
337-338
模拟枚举类型,338
锁定(locking),341
替代方案,339-342
信息隐藏问题,95-96
要点,344
用以保存值,338
语义耦合(semantic
coupling),102
在类中隐藏实现,153
中间结果,避免,343
重构(refactoring),568
注释(annotating),343
注释(commenting),803,809
子程序用作参数,336
缺陷,代码中的(defects in code)
《代码大全》示例,490-491
百分比,测量,469-472
查找,核对表,559-560
程序员失误(programmers at
fault),519
错误核对表,489
范围,519
分布(distribution),517-518
分类(classification),518-520
根源,表格,518
构建,比例,520-521
构建领域之外,519
间断(intermittent),542-543
检测的成本,472
可读性改善(readability
improvements),538
拼写错误(clerical errors
(typos)),519
期望率(expected rate),
521-522
容易修正的缺陷,519
数据库(database),527
通过各种技术检测,表格,470
稳定(stabilizing),542-543
误解设计,根源,519
项目规模的影响,651-653
性能问题,601
修复,参见:调试,修复缺陷
修复的成本,472-473
易错的类,517-518
益处,537-538
正式检查(formal
inspections),检测缺陷,参
见:详查(formal
inspections)
重构,在修复之后,582
自己从中学到知识,538
(R)
绕弯解决(workaround),说明
(commenting),800
人的方面(human aspects),软件中
个人的
开发,参见:性格
日志
测试工具,526
防御式编程指南,210
容错(fault tolerance),50
容器类(container classes),310
软件参考书目(bibliographies,
software),858
软件的首要技术使命(Software's
Primary Technical Imperative),92
软件的质量(software quality)
标准,IEEE,477,814
测试,465,467,500-502
程序员的工作表现,基于的目
标,468-469
调试,所扮演的角色,
474-475,536
对变更进行控制的过程,468
发展质量保证活动,467-468
复查,467
核对表,476
极限编程,471-472
建议联合使用多种技术,473
建议综合各种缺陷检测技术,
470-471
健壮性,464
结果的量化,468
精确性,464
可读性,464
可靠性,464
可理解性,465
可维护性,464
可移植性,464
可用性,463
可重用性,464
灵活性,464
门,467
明确定义质量保证工作,466
目标,设置,466,468-469
内在特性,464-465
缺陷度量百分比,469-472
缺陷检测的若干技术,表格,
470
软件工程指南,467
软件质量的普遍原理,
474-475
什么时候进行质量保证工作,
473
适应性,464
特性之间的联系,465-466
外部审查,467
外在特性,463-464
完整性,464
相关资源,476
效率,464
协作构建,参见:协作
修正缺陷的成本,472-473
索 引
代码大全(第2版)
934
要点,477
优化竞争关系,465-466
原型制作,468
找出缺陷的成本,472
正确性,463
软件工程的资源综述,858
软件工程指南,467
软件构建概述
编程就是构建,5
编程与构建的比较,4
定义,3-6
非构建活动,6
构建活动,清单,3
"确保完成"之本性,7
任务,清单,5
软件开发的核心活动,7
软件开发总时间的比例,7
生产率,重要性,7
要点,8
源代码对软件的描述,7
源代码即为软件描述,7
重要性,6-7
主要活动,4
软件开发文件夹(SDF, Software
Development Folder),778
软件开发者的阅读计划,860-862
软件开发资料库
参考书目,858
概述,855,857-858
构建,856
软件工程综述,858
阅读计划,860-862
杂志,859-860
软件设计,参见:设计
软件生长隐喻,15-16
软件先知,851
软件项目类型,31-33
软件演化
背景,563-564
构建与维护,564
基本准则,565
哲学,564-565
质量提高与降低,564
软件演化的基本准则(Cardinal Rule
of Software Evolution),565
软件隐喻,参见:隐喻,软件
软件质量,参见:软件的质量
软件质量的普遍原理(General
Principle of Software Quality)
成本,522
调试,537
定义,474-475
协作效果,481
(S)
三明治集成(sandwich integration),
698-699
三思而后行,23
扇出(fan-out),81
扇入(fan-in),80
舍入误差,297
设计(design)
BDUF(Big Design Up Front),
119
IEEE标准,122
UML图,118
包的层次,82-85
本质问题(essential
problems),77-78
变更,标明区域,97-99
变更的管理,666-667
标准,IEEE,122
标准技术目标,81
测试实现,503
层次(hierarchies),105-106
层次(levels),82-87
层次性目标(stratification
goal),81
抽象,形成一致的,89-90
低,中扇出的目标
(low-to-medium fan-out
goal),81
迭代实践,111-117
定义,74
对象,真实世界,找出,87-89
非确定性的本质
(nondeterministic nature),
76,87
分而治之(divide and conquer)
技术,111
封装(encapsulation),90-91
高扇入目标(high fan-in
goal),80
高质量的特性,80-81
工具,710
构建活动,73-74
管理复杂度,77-80
核对表,122-123,781
绘制图表,107
记录工作,117-118
继承(inheritance),91-92
精简性目标(leanness goal),
81
可复用性目标(reusability
goal),80
可扩展性目标(extensibility
goal),80
可视化文档(visual
documentation),118
可移植性目标(portability
goal),81
类,分解为,86
了无章法的过程(sloppy
process),75-76
量度(metrics),警告信号,
848
美感(beauty),80
面向对象(object-oriented)的
资源,119
模式,常用,参见:模式
目标核对表,122-123
偶然(次要)的问题(accidental
problems),77-78
耦合(coupling)方面的考虑,
100-102
启发式(heuristic),参见:启
发式设计
契约式(contract),233
强内聚(strong cohesion),105
权衡(tradeoff),76
软件系统层次,82
实践,110-118,122
实践启发式方法,参见:启发
式设计
受限,76
数据库访问子系统,85
松耦合目标(loose coupling
goal),80
讨论,总结,117
完备度,确定,115-117
维护性目标(maintenance
goals),80
维基(wiki),记录,117
文档,当作,781
文档,过度,117
系统依赖子系统,85
险恶的问题(wicked
problem),本质,74-75
详细程度,115-117
协作(collaboration),115
信息隐藏(information
hiding),92-97,120
性能调整方面的考虑,
589-590
严格描述类的契约(class
contracts),106
要点,123
业务逻辑子系统,85
用户界面子系统,85
优良实践表,31-32
优先级的确定(prioritizing),
76
原型(prototyping),114-115
正式程度(formality),确定,
115-117
智力限制(mental
limitations),人类,79
中央控制点,107
索 引
代码大全(第2版)
935
资源,119-121
子程序,86-87
子系统层次,82-85
子系统之间的通信,83-84
自上而下的方法,111-113
自然形成(emergent nature),
76
自下而上设计法,112-113
足够,确定,118-119
设计的层次
包,82-85
对系统有依赖性的子系统,85
概述,82
类,分解为,86
软件系统,82
数据库访问子系统,85
业务逻辑子系统,85
用户界面子系统,85
子程序,86-87
子系统,82-85
设计的受限制特性,76
设计过程的不确定性,76,87
设想陈述的先决条件,参见:问题定
义的先决条件
设置代码,重构,568-569
深入语言去编程,68-69,843
神秘变量,避免,292,297-298,
308-309
生产率
良好构建活动的作用,7
项目规模,影响,653
业界平均值,474
生命周期模型
开发标准,813
优良实践表,31-32
声明(declaration)
const,建议,243
final,建议,243
放置,762
格式化(formatting),761-763
靠近第一次使用的地方定义
的原则,242-243
命名,参见:命名约定
使用全部已声明的变量,257
数值数据,注释,802
顺序,762
一行多个,761-762
隐式声明(implicit
declaration),239-240
指针(pointer),325-326,763
注释(commenting),794,
802-803,816
实例化对象
抽象数据类型(ADT),132
单件(singleton),104,151
工厂方法(Factory Method)
模式,103-104
"使代码易于自上而下地阅读"的指
导建议,351-352
性命攸关的系统,31-32
使用结构体交换数据,321-322
事件处理器(event handlers),170
试验,作为学习方法(experimentation
as learning),822-823,852-853
试验性原型(experimental
prototyping),114-115
适配器(Adapter)模式,104
适应性(adaptability),464
释放(deallocation)
goto语句,399
指针(pointer),of,326,330,
332
释放对象(disposing of object),206
收尾步骤(cleanup step),伪代码编
程过程,232
收尾代码,重构,568-569
受保护数据,148
书本范例(book paradigm),812-813
输入/输出(I/O)
架构的先决条件,49
识别容易变化的区域,98
性能考虑,598-599
输入/输出,参见:I/O(输入/输出)
输入参数,274
数据(data)
变更,确定区域,99
测试,生成器,524-525
代码调整,参见:数据变换,
为代码调整
好数据,测试,515-516
坏数据,测试,514-515
架构的前期准备,46
旧数据,兼容性,516
类型(type),参见:数据类
型
设计,46
已定义的状态(defined state),
509-510
已定义-已使用路径
(defined-used path),测试,
510-512
已进入的状态(entered state),
509
已使用的状态(used state),
509-510
已推出的状态(exited state),
509
已销毁的状态(killed state),
509-510
正常情况的错误(nominal
case errors),515
组合状态(combined states),
509-510
数据变换(data transformation),为
代码调整
浮点转为整形,625
缓存数据,628-629
目的,624
让数组维度最小,625-626
让数组引用最少,626-627
索引数据,627-628
数据级重构,571-572,577
数据记录工具,526
数据结构(data structure),参见:结
构
数据库(database)
SQL语言,65
性能问题,601
子系统设计,85
数据类型(data type)
"a"前缀,272
"t_"前缀,272
变更,标明区域,99
变量,区分,272-273
布尔(boolean),参见:布尔
变量
抽象数据类型(abstract data
type),参见:抽象数据类
型(ADT)
创建,参见:类型创建
迭代型数据(iterative data),
255
定义,278
二进制编码的十进制数
(BCD),297
浮点(floating-point),参见:
浮点数据类型
复杂(complex),参见:结构
过多使用的基本数据类型
(primitives),567
核对表,316-318
货币数据类型(Currency),
297
结构,参见:结构
枚举类型(enumerated type),
参见:枚举类型
命名,273,277,278
数值,参见:数值数据类型
数组(array),参见:数组
序列型数据(sequential data),
254
选择型数据(selective data),
254
要点,318
用户定义的(user-defined),
参见:类型创建
与控制结构的关系,254-255
索 引
代码大全(第2版)
936
整型(integer),参见:整数
数据类型
指针(pointer),参见:指针
重构为类,567,572
资源,239
字符,参见:字符数据类型
字符串,参见:字符串数据类
型
数据流测试(data flow testing),
509-512
数据认知测试(data literacy test),
238-239
数据字典(data dictionaries),715
数值,文字量,292
数值数据类型
0,除以0,292
BCD(二进制编码的十进制),
297
比较,440-442
编译器警告,293
操作开销,602
浮点类型,295-297,316,602
核对表,316
混合类型的比较,293
神秘数值,避免,292
声明,注释,802
数量级,相差巨大,运算,295
数值文字量,避免,292
溢出,293-295
硬编码的0和1,292
整数,293-295
整数取值范围,294
转换,展示,293
数组(array)
C语言中的宏,311
foreach循环,372
操作代价,602
串话(cross-talk),311
定义,310
端点(end points),检查,310
多维(multidimensional),310
核对表,317
命名约定,280-281
容器作为替补,310
哨兵值(sentinel),循环检测,
621-623
顺序访问的指导建议,310
维数(dimension),最小化,
625-626
下标(index),310-311
性能调整,593-594,603-604
循环,387-388
引用(reference),最小化,
626-627
引用的布局(layout of
references),754
语义前缀(semantic prefixes),
280-281
重构(refactor),572
顺序上的内聚性,168
私用数据,148
松散耦合
策略,100-102
作为设计目标,80
算法(algorithm)
隐喻(metaphor),11-12
与启发式方法/试探法
(heuristics)的比较,12
注释,809
资源,607
子程序,223
算术表达式(arithmetic expression)
乘法,改为加法,623-624
舍入误差(rounding errors),
297
数量级相差巨大的数之间的
加减运算,295
误导的优先级(precedence)
示例,733
随机数据生成器,525
缩进,737,764-768
索引,辅助以数据类型,627-628
索引访问表,425-426,428-429
锁定全局数据,341
(T)
调试(debugging)
diff工具,556
lint工具,557
编译器,作为调试工具,549,
557
变更,最近的,547
表现上的差异,536-537
猜测,539
测试,比较,500
测试用例创建,544
查找缺陷(defects),540,
559-560
忏悔式调试(confessional
debugging),547-548
常见的缺陷清单,547
成本(cost),29-30,474-475
程序员经验的影响,537
重新检查易错代码
(defect-prone code),547
单元测试,545
低效方法,539-540
定位错误源,543-544
定义,535
断点(breakpoint),558
多条编译信息,550
二分查找(binary search),代
码,546
防御式(defensive),参见:
调试助手
符号调试器(symbolic
debuggers),526-527
各种测试用例,545
工具,526-527,545,556-559,
719;参见:调试助手
行数,549
核对表,559-561
假想测试(hypothesis
testing),543-544,546
脚手架(scaffolding),558
警告,视为错误,557
科学方法,540-544
可读性的改进,538
扩大嫌疑范围,547
理解问题,539
历史,535-536
列出可能性,546
逻辑检查工具,557
蛮力(brute-force),548-549
盲目的根源,554-555
迷信的方法,539-540
"魔鬼的助手"(Satan's
helpers),539-540
缺陷当作机遇,537-538
软件质量中的角色,536
时间,设置上限,549
缩小代码搜索范围,546
调试工具,526-527,545,
556-559,719;参见:调试
助手
推荐的方法,541
唾手可得的修复,539
稳定错误(stabilizing errors),
542-543
系统调试器,558
项目范围的编译器设置,557
心理方面(psychological)的
考虑,554-556
休息一下,548
修复缺陷,550-554
要点,562
引号,误置的,550
语法检查,549-550,557,560
源代码比较器(source-code
comparator),556
增量的方法,547
执行剖测器(execution
profiler),557-558
助手,参见:调试助手
注释,误置的,550
资源,561
自己从中学到知识,538
索 引
代码大全(第2版)
937
调试助手(debugging aids)
C++的预处理器
(preprocessors),207-208
case语句,206
版本控制(version control)工
具,207
产品约束,开发版本,205
存根(stub),208-209
攻击式编程(offensive
programming),206
计划移除,206-209
尽早引入,建议,206
目的,205
预处理器(preprocessor),
207-208
指针,检查,208-209
条件语句(conditional statement)
case语句,参见:case语句
else子句,358-360
if-then-else语句串(chain),
358-360
if语句,参见:if语句
switch语句,参见:case语句
按频率顺序进行判断,
612-613
布尔变量(boolean variable),
推荐,301-302
调用布尔函数(boolean
function),359
查询表(lookup table),替代,
614-615
常见情况置先(common cases
first)原则,359-360
错误处理示例,356-357
定义,355
短路求值(short-circuit
evaluation),610
覆盖所有情况,360
核对表,365
空if子句,357
普通if-then语句,355-357
相等(equality),分支,355
消除测试冗余(testing
redundancy),610-611
性能比较,614
循环,条件(conditional),参
见:循环
要点,366
正常路径置先(normal path
first)建议,355
正常情况置先(normal case
first)建议,356-357
重构(refactoring),573
通信上的内聚性(communicational
cohesion),169
图表(diagram)
UML(Unified Modeling
Language),118
启发式设计(heuristic
design),使用,107
图目录,xxxiii
图形化设计工具,710
图形用户界面(GUI)
架构(architecture)的前期准
备(prerequisites),47
重构(refactor)其中的数据,
576
子系统(subsystem)设计,
85
团队(team),参见:管理构建
build小组,704
分配时间,681
风格问题,683-684
管理者,686
过程,重要性,839-840
核对表,69
扩充团队以便赶上进度,676
私密的办公室,684
所用的开发过程,840
物理环境,684-685
相关资源,685-686
项目规模,影响,650-653
信仰问题,683-684
性能差异,681-683
团队软件开发过程(TSP,Te a m
Software Process),521
退出循环,369-372,377-381
(W)
外部审查(external audit),467
外部文档(external documentation),
777-778
外观(Facade)模式,104
完整性,464
万能类(god class),155
维护(maintenance)
可读性(readability)的好处,
842
可维护性(maintainability)的
定义,464
容易出错的子程序,排优先级
(prioritizing),518
设计目标,80
修复缺陷(defects),源于维
护的问题,553
用结构体(structure)来减少
维护,323
注释(comment)所需的维护,
788-791
伪代码(pseudocode)
PPP(伪代码编程过程),参
见:伪代码编程过程
PPP(伪代码编程过程),核
对表,233-234
变更,效率,220
不好的示例,218-219
测试,计划,222
创建伪代码的要点,234
从代码库中寻求功能,222
从伪代码进行编码,225-229
从伪代码进行高层次的注释,
226-227
从伪代码进行声明,226
从伪代码进行注释,220,791
错误处理的注意事项,222
迭代精化(iterative
refinement),219,225
定义,218
好处,219-220
好的示例,219
检查错误,230-231
类,创建步骤,216-217
命名子程序,222
审阅,224-225
算法,研究,223
问题定义,221
先决条件(prerequisite),221
性能的注意事项,222-223
循环设计,385-387
有效使用伪代码的指导建议,218
在注释下面填充代码,
227-229
重构(refactoring),229
子程序(routine),创建步骤,
217,223-224
子程序设计,220-225
子程序示例,224
子程序数据结构,224
子程序头部注释(header
comment),223
伪代码编程过程(PPP,Pseudocode
Programming Process)
编写伪代码的步骤,223-224
测试代码,222, 231
程序库中已有的功能,222
从伪代码编写子程序,
225-229
错误处理的注意事项,222
迭代(iteration),225
定义,218
高层次(high-level)注释,
226-227
核对表,233-234
检查错误,230-231
设计子程序,220-225
审查(review)伪代码,224-225
收尾工作(cleanup steps),232
算法(algorithm)研究,223
索 引
代码大全(第2版)
938
替代方案,232-233
问题定义(problem
definition),221
先决条件(prerequisites),221
消除错误,231
性能方面的考虑事项,
222-223
要点,234
源于伪代码的声明
(declarations),226
在注释(comment)下面填充
代
码,227-229
重复步骤,232
重构(refactoring),229
逐行执行(stepping through)
代码,231
子程序的数据结构(data
structure),224
子程序命名,222
子程序示例,224
子程序头部注释,223
文档(documentation)
CRC(class-responsibility-colla
borator) 卡片,118
Javadoc,807,815
标准,IEEE,813-814
参数假定(parameter
assumptions),178
抽象数据类型(abstract data
type),128
单元开发文件夹(UDF,Unit
Development Folder),778
风格差异(style difference),
管理,683
核对表,780-781,816-817
坏代码,568
记录工作,117-118
可视化,设计,118
控制结构(control structure),
780
类(class),780
名称,284-285,778-779,780
名称的缩写,284-285
软件开发文件夹(SDF,
Software Development
Folder),778
设计作为文档,117,781
书本范例(Book Paradigm),
812-813
数据的组织,780
外部(external),777-778
为何与如何(why vs. how),
797-798
伪代码(pseudocode),得自,
220
详细的设计文档(detailed-
design documents),778
项目规模的影响,657
要点,817
依赖性(dependency),明确,
350
源代码作为文档,7
注释(comments),参见:注
释
资源,815
子程序(routine),780
子程序参数假定(parameter
assumptions),178
自说明的代码(self-
documenting code),778-781
文件(files)
C++源文件顺序,773
布局(layout),771-773
抽象数据类型(ADT),视为,
130
改动记录(authorship
records),811
命名,772,811
删除多个,示例,401-402
文档,810-811
子程序(routine),772
稳定错误(stabilizing errors),
542-543
问题定义的先决条件,36-38
问题域(problem domain),基于问
题域编程,845-847
无限循环(endless loop),367,374
无效输入,参见:合法性校验
(X)
析构函数(destructor),异常,199
习惯(habit),程序员的,833-834
系统测试,500
系统调用(system call)
代码调整,633-634
性能问题,599-600
系统干扰器(perturber),527
系统级重构,576-577,579
系统架构,参见:架构
系统生长(accreting a system)的隐
喻,15-16
下标(index),循环
变量名,265
核对表,389
枚举类型,305
替代方案,377
最终取值,377-378
作用域,383-384
先知(oracle),软件,851
险恶的问题(wicked problem),74-75
线程(thread),337
相等(equality),浮点数,295-296
详查(formal inspections)
《代码大全》示例,490-491
CMM(能力成熟度模型),491
报告,488-489
表现评估(performance
appraisals),487
场景方法(scenarios
approach),488
错误核对表,489
代码评审(code review)的速
度,488
定义,485
返工阶段(rework stage),489
概述阶段(overview stage),
487
跟进阶段(follow-up stage),
489
过程,487-489
核对表,491-492
计划阶段(planning stage),
487
记录员角色(scribe role),486
角色(roles),486-487
阶段(stages),487-489
经理角色(management role),
486-487
评审员角色(reviewer role),
486
评审(review),比较,485
期望的结果,485-486
三小时解决方案会议
(three-hour solutions
meeting),489
细调(fine-tuning),489
详查会议(inspection
meeting),488
要点,497
益处总结,491
与其他协作方法的比较,
495-496
责备游戏(blame game),490
主持人角色(moderator role),
486
准备阶段(preparation stage),
487-488
资源,496-497
自尊心(ego),490
作者角色(author role),486
详查(inspection),参见:正式检查
(formal inspection)
详查中的记录员(scribe)角色,486
详查中的评论员(reviewer)角色,486
详查中的主持人(moderator)角色,
486
详查中的作者(author)角色,486
索 引
代码大全(第2版)
939
详细设计文档(detailed-design
documents),778
项目规模
单一产品,一个用户,656
单一产品,多个用户,656
范围,651
方法论的注意事项,657-658
复杂度(complexity),影响,
656-657
概述,649
估算误差,656-657
活动,快速增长的活动清单,
655
活动类型,影响,654-655
建筑隐喻,19
人与人交流,650
生产率,影响,653
文档(documentation)要求,
657
系统,656
系统产品,656
相关资源,658-659
要点,659
引发的错误,影响,651-653
正规性(formality)要求,657
项目种类,相应的前期准备,31-33
效率(efficiency),464
协作(collaboration)
标准,IEEE,497
测试,比较,481
成本优势,480-481
传承(mentoring)方面,482
代码阅读,494
定义,479,480
公开演示(dog-and-pony
shows),495
构建之后继续保持协作,483
极限编程法(Extreme
Programming method),482
集体所有权(collective
ownership)的好处,482
技术对比表,495-496
结对编程(pair
programming),参见:结对
编程
开发时间(development time)
的好处,480
目的,480
软件质量的普遍原理(General
Principle of Software
Quality),481
设计阶段(design phase),115
详查(inspections),参见:正
式检查(informal
inspection)
要点,497
正式检查(formal
inspections),参见:正式检
查
走查(walk-throughs),492-493
心理距离,556
心理取向,554-555
心理因素,参见:性格,个人
信息隐藏(information hiding)
抽象数据类型(ADT),127
创建类型,313-314
访问器(accessor)子程序,
340
隔栏,95-96
过度分散的问题,95
接口,类,93
类的隐私权,92-93
类的内部数据误为全局数据,
95-96
类设计的注意事项,93
类的实现细节,153
例子,93-94
秘密的概念,92
秘密的种类,94
性能问题,96
循环依赖的问题,95
重要性,92
资源,120
性能调整(performance tuning)
DES(数据加密标准)示例,
605-606
编码的用户角度,588
编译器的注意事项,590,
596-597
不成熟的优化,840
操作,常见操作的开销,
601-603
操作系统的注意事项,590
从程序需求角度看,589
从设计角度看,589-590
代码调整,参见:代码调整
代码缺陷,601
代码行,减少代码行数,
593-594
代码质量,影响,588
低效的元凶,598-601
方法总结,606
分页操作(paging operation),
599
概述,643-644
何时调整,596
核对表,607-608
计时问题,604
架构的前期准备,48
解释型(interpreted)语言与
编译型(compiled)语言的
比较,600-601
目的,587
内存操作与文件操作的比较,
598-599
权衡程序目标,595,605
输入/输出,598-599
数据库索引,601
数组,593-594,603-604
速度,重要性,595-596
算法选择,590
无稽之谈,593-596
系统调用,599-600
相关资源,606-607
信息隐藏的注意事项,96
性能测量,603-604
要点,608
硬件的注意事项,591
正确性,重要性,595-596
注释,影响,791
专为功能进行性能调整,595
资源占用目标,590
子程序设计,165,222-223,
590
匈牙利命名法(Hungarian naming
convention),279
修复缺陷(defect)
保存未修复的代码(unfixed
code),552
变更的理由,553
初始化缺陷(initialization
defects),553
匆忙,影响,551
单元测试(unit test),554
核对表,560
检查修复情况,553
先要理解问题(understand
first)的建议,550-551
特殊情况(special cases),553
维护事宜,553
相似缺陷,查找,554
一次一改的原则(one change
at a time rule),553
诊断确认(diagnosis
confirmation),551
症状,修复问题根源,552-553
需求(requirement)
变更控制(change-control)过
程,40-41
变化率,典型值,563
不报告就写代码,26
测试,503
定义,38
放弃(dump)项目,41
非功能需求,核对表,42
功能需求,核对表,42
好处,38-39
索 引
代码大全(第2版)
940
核对表,40,42-43
交流变更,40-41
开发方法,41
开发过程对需求的作用,40
良好实践表,31-32
配置管理(configuration
management),664,666-667
商业案例,41
完备性,核对表,43
稳定需求,39-40,840
性能调整,589
需求错误,影响,38-39
需求的质量,核对表,42-43
需求开发的相关资源,56-57
要点,60
允许的时间,55-56
重要性,38-39
需求的完备性,核对表,43
序列,代码,参见:用子程序隐藏块,
165
结构化编程的概念,454
顺序,参见:依赖关系,代码
顺序
序列式开发法,33-36
选择,代码,455
选择性(selective)数据,254
循环(loop)
break语句,371-372,379-380,
381
continue语句,379,380,381
do循环,369-370
foreach循环,367,372
for循环,372,374-378,
732-733,746-747
off-by-one(差1)错误,
381-382
repeat-until子句,377
while循环,368-369
安全计数器,378-379
变量初始化,249
变量的指导原则,382-384
变量核对表,389
变量命名,382-383
长度,385
长度削减,623-624
初始化代码,373,374
串话(cross talk),383
代码调整,616-624
带goto的循环,371
带标号的break语句,381
迭代器循环,367,456
迭代型数据结构,255
定义,367
端点的注意事项,381-382
多条break语句,380
非正常循环,371
改动循环下标,377
合并,617-618
核对表,388-389
后续行,757
计数循环,367;参见:for循
环
建议的括号,375
尽可能减少循环内部的工作,
620-621
进入循环的指导建议,
373-375,388
空循环,避免,375-376
空语句,重写,445
连续求值的循环,367;参见:
while循环
枚举类型,305
内务语句,376
嵌套,382-383,385,623
嵌套的放置次序,623
切换(switch),616
确认终止条件,377
融合,617-618
冗余判断,消除,610-611
哨兵值(sentinel)判断,
621-623
设计,过程,385-387
数组与循环的关系,387-388
特定语言,循环种类表,368
退出循环的指导原则,
369-372,377-381,389
外提判断,616-617
伪代码方法,385-387
问题,概述,373
无限循环,367,374
下标(index)的变量名,265
下标(index)的最终取值,
377-378
下标(index)的作用域,
383-384
性能的注意事项,599
循环规模作为重构指示,565
循环结束条件检查,位置,368
循环内的指针,620
循环体,处理,375-376,388
循环下标的核对表,389
要点,389
"一个循环只做一件事"的指
导建议,376
展开,618-620
终止条件,使之明显,377
种类,推广,367-368
重构,565,573
注释,804-805
子程序,385
组合判断,简化,621-623
循环的哨兵值(sentinel)判断,
621-623
循环依赖(circular dependencies),
95
循环展开,618-620
循环中的安全计数器,378-379
(Y)
延迟提交策略(commitment delay
strategy),52
演化(evolution),参见:软件演进
演进式交付(Evolutionary Delivery),
参见:增量式开发隐喻
业务规则(business rule)
变更,标出其区域,98
架构的先决条件,46
良好实践表,31-32
子系统设计,85
依赖性(dependency),代码顺序
(code-ordering)
不明显的,348
参数,有效的,349
初始化顺序,348
错误检查,350
概念,347
检查工具,716
明确,348-350
命名子程序,348-349
文档,350
循环(circular),95
隐藏,348
组织代码,348
"已定义的"数据状态(defined data
state),509-510
"已使用的"数据状态(used data
state),509-510
"已销毁的"数据状态(killed data
state),509-510
以人为本的方案,参见:可读性
异常(exceptions),参见:错误处理
C++语言,198-199
Java语言,198-201
Visual Basic语言,198-199,
202
标准化(standardizing)其使
用,202-203
抽象层次(abstraction level)
的规则,199-200
抽象问题,199-200
防御式编程(defensive
programming),核对表,211
非异常的条件(non-
exceptional condition),199
封装(encapsulation),破坏,
200
构造函数(constructor),199
基类(base class),项目特定,
索 引
代码大全(第2版)
941
203
集中报告机制(centralized
reporter),201-202
局部处理(local handling)的
规则,199
可读性(readability),199
空的catch语句块的规则,201
库代码的生成,201
目的,198,199
全部信息(full information)
规则,200
替代方案,203
析构函数(destructor),199
语言比较表,198-199
重构(refactoring),577
资源,212-213
易于维护(ease of maintenance)设
计目标,80
溢出(overflow),整数,293-295
引用符(&),C++,332
隐藏,参见:信息隐藏
隐含实例(implicit instancing),132
隐式声明(implicit declaration),
239-240
隐喻(metaphor),软件
地心说与日心说,10-11
定制,18
耕作,14-15
工具箱(toolbox)法,20
过度引申(overextension),10
基于隐喻的发现,9-10
简单结构与复杂结构,16-17
建造,隐喻,16-19
可读性,13
牡蛎养殖,15-16
抛弃一个,13-14
培植系统,14-15
启发式(heuristic)方法,12
生长系统,15-16
使用建模式(modeling)的隐
喻,9
使用算法式(algorithmic)的
隐喻,11,12
使用隐喻,11-12
示例,13-20
威力,10
相对优点,10,11
项目规模,19
写作代码示例,13-14
要点,21
以计算机为中心与以数据为
中心,11
造组件还是买组件,18
增量开发,15-16
钟摆示例,10
重要性,9-11
组合,20
硬件(hardware)
性能增强,借助,591
依赖,改变,98
用递归(recursion)穿越迷宫的示例,
394-396
用户界面(user interface)
重构数据,576
架构的前期准备,47
子系统设计,85
用户自定义类型(UDT,User Defined
Ty p e),279-280
优化,不成熟的,840;参见:性能
调整
优先级,误导,733
"有一个(has-a)……"的关系,
143
右移(right shift),634
语法,错误,549-550,560,713-714
语句(statement)
不完整的,754-755
长度,753
核对表,774
后续行的布局(endline
layout),754-758
后续行的结尾,756-757
紧密关联的元素,755-756
顺序,参见:直线型代码
重构,572-573,577-578
语句块(block)
纯块,布局风格(pure,layout
style),738-740
单条语句,748-749
定义,443
花括号(brace)书写规则,443
模仿的纯块布局风格,
740-743
条件,明确,443
注释,795-796
语言,编程,参见:编程语言选择
语义检查器(semantics checker),
713-714
语义前缀(semantic prefix),280-281
语义上的耦合(semantic coupling),
102
预处理器(preprocessor)
C++语言,207-208
编写,208
调试辅助(debugging aid),
移除,207-208
目的,718-719
预先做大量的设计(BDUF,Big
Design Up Front),119
员工表现评估,487
原型建立(prototyping),114-115,
468
源代码(source-code)
文档,7
资源,815
源代码(source-code)工具
diff工具,712
grep工具,711
merge(合并)工具,712
版本控制(version control)工
具,715
比较工具,556
编辑器,710-713
尺度报告器(metric reporter),
714
多个文件中查找字符串,
711-712
翻译器(translator),715
分析代码质量,713-714
集成开发环境(IDE),710-711
交叉引用(cross-reference)工
具,713
接口文档,713
结构改组(restructuring)工具,
715
类的继承体系生成器(class
hierarchy generator),713
美化器(beautifier),712
模板,713
数据字典,715
语法检查器(syntax checker),
713-714
语义检查器(semantic
checker),713-714
重构工具,714-715
阅读是一项技能,824
允许的时间,55-56
运行期(runtime),绑定(binding),
253
(Z)
增量集成(incremental integration)
T型(T-Shaped)集成,701
步骤,692
测试驱动,697
策略,概述,694
成果,及早,693
垂直分块(vertical-slice)法,
696
存根(stub),694,696
错误,定位,693
定义,692
方法小结,702
分块(slice)法,698
风险导向(risk-oriented)的 集
成,699
改善对进度的监控,693
索 引
代码大全(第2版)
942
改善客户关系,694
功能导向(feature-oriented)
的集成,700-701
接口定义,695,697
进度的好处,694
类,694,697
三明治(sandwich)策略,
698-699
益处,693-694
资源,708
自下而上策略,697-698
自上而下策略,694-696
自上而下策略的缺点,
695-696
增量开发,隐喻,15-16
折中主义(eclecticism),851-852
针对非功能需求的核对表,42
针对功能需求的核对表,42
整数(integer)数据类型
除法(division)注意事项,
293
核对表,316
取值范围,294
溢出,293-295
运算开销,602
正确性,197,463
正式的技术复审(technical reviews),
467
执行剖测器(execution profilers),
557-558,720
直接访问表(direct access table)
case语句,421-422
保险费率示例,415-416
变化键值(transforming
keys),424
定义,413
对象方法(object approach),
422-423
构造键值(fudging keys),
423-424
键值(keys),423-424
灵活的消息格式,示例,
416-423
设计方法,420
数组(array),414
一个月中的天数示例,
413-414
优点,420
直线型(straight-line)代码
把相关的语句组织在一起,
352-353
不明显的依赖关系,348
参数,明确显示,349
初始化顺序,348
错误检查,350
核对表,353
就近原则,351
明确顺序,要求,347-350
命名子程序,348-349
说明,350
突显依赖关系,348-350
显现依赖关系的组织形式,
348
依赖关系的概念,347
隐藏依赖关系,348
指数表达式(exponential
expressions),631-632
指针(pointer)
&(指针引用符),332
*(指针声明符),332,
334-335,763
->(指针符),328
auto_ptr,333
C++使用指针的指导原则,
332-334
C++示例,325,328-334
C++指针引用,332
C语言,334-335
C语言的字符串操作,299
null,当作警告信号,849
null,删除指针后将其置为
null,330
SAFE_子程序,331-332
sizeof(),335
按引用(by reference)传递,
333
边界检查工具,527
不提供指针的语言,323
初始化,241,244,325-326
地址(address),323,326
调试辅助,208-209
分配,326,330,331
覆盖子程序,331-332
狗牌字段(dog tag field),
326-327
核对表,344
画图,329
简化复杂的指针表达式,329
类型转换,避免,334
链表,删除其中的指针,330
明显的冗余字段,327
内存地址内容的解释,
324-325
内存后备区域(parachutes),
330
内存中的位置,323
内容,解释,324-325
删除,330-331,332
声明,325-326,763
释放,326,330,332
替代方案,332
通过子程序隐藏指针操作,
165
危险性,323,325
先检查再使用,326,331
显式类型,334
限制指针操作,325
相关资源,343
星号规则(*),334-335
要点,344
引起的内存破坏(corruption),
325-327
引用变量,检查,326
用额外的指针变量来提高代
码清晰度,327-329
用垃圾数据覆盖内存区域,
330
与0比较,441
指向的数据类型,324-325
指针作为函数返回值,182
智能指针(smart pointer),334
组成部分,323
质量保证(quality assurance),参见:
软件质量
核对表,70
软件项目的良好实践表,
31-32
需求核对表,42-43
在前期准备中的职责,24
质量门(quality gate),467
智慧工具箱方法,20
智能指针(smart pointer),334
中-低扇出(fan-out)设计目标,81
主要构建实践,核对表,69-70
注释(comment),参见:文档
/* vs. //,790
Javadoc,807,815
版本控制(version control),
811
比例(proportionality),806
编码含义(coded meanings),
802-803
变量,803
标记(marker),787
标准,IEEE,813-814
布局(layout)指导建议,
763-766
参数声明(parameter
declarations),806-807
程序的各部分,809
错误,标注绕弯解决方法
(marking workarounds),
800
代码段落,795-801,816
代码无法表达的信息,788
代码意图(code intent)的层
次,795-796
单行代码,792-795
索 引
代码大全(第2版)
943
法律声明(legal notices),811
风格,违背,801
风格差异,管理,683
富于技巧的代码(tricky
code),798,801
概述代码,787
高效创建,788-791
核对表,774,816-817
集成到开发中,791
接口,类,810
接口,子程序,808
解释(explanatory),786
惊奇,798
空行,周围的,765-766
控制结构(control structure),
804-805,817
烂代码(bad code),568
类(class),810
目的,782
全局变量(global variable),
803,809
绕弯解决(workaround),800
声明(declaration),794,
802-803,816
书本范例(Book Paradigm),
812-813
输出数据,808
输入数据,803,808
数值数据,802
说明代码意图(code intent),
787
说明(description)的长度,
806
苏格拉底式(Socratic)对话,
781-785
算法(algorithm),809
缩进(indentation)指导建议,
764-765
缩写(abbreviation),799
为何与如何(why vs. how),
797-798
维护,220,788-791,794
伪代码(pseudocode),得自
于,220,784,791
未公开的功能特性
(undocumented features),
800
位标志(flags,bit level),803
文件,810-811
先于代码(preceding code)的
原则,798
行尾(endline)注 释 ,793-795
性能考虑,791
循环(loop),804-805
要点,817
与代码距离的指导建议,806
争论,782
种类,786-788
重复代码,786
主要与次要,799-800
资源,815
子程序,805-809,817
自说明的代码(self-
commenting code),796-797
最佳密度(optimum density),
792
作者(authorship),811
专业开发,824-825
专业组织,862
转换数据类型,635
桩对象(stub object),测试,523
装饰器(Decorator)模式,104
状态报告,827
状态变量(status variable)
变化,明确区域,98-99
变量名,266-267
枚举类型,266-267
位一级(bit-level)的含义,
803
用状态变量重写goto语句,
403-404
语义上的耦合(semantic
coupling),102
状态变量,参见:状态变量
准备,参见:前期准备,前期
准备不周全的准备,诱因,25-27
资料库,书籍,参见:软件开发资料
库
资源管理(resource management)
架构,47
释放资源的示例,401-402
子程序(routine)
PPP(伪代码编程过程)核对
表,233-234
编译找错,230-231
变量名,区分,272
不使用,重构,576
布尔判断的好处,165
布局,754,766-768
参数,参见:子程序的参数
测试,222,231,523
测试先行的开发方法,233
查询,重构,574
长度,指导建议,173-174
抽象的好处,164
抽象且可覆盖(abstract and
overridable)的子程序,145
创建in关键字,175-176
创建out关键字,175-176
创建理由,清单,167
创建子程序的正当理由,
164-167
从库中寻求功能,222
从伪代码编码,225-229
错误处理的注意事项,222
错误类,暗示,566
代码调整,639-640
低质量示例,161-163
调用,开销,601
调用的后续行,756
迭代伪代码,225
定义,161
定义子程序要解决的问题,
221
东拼西凑法,233
对象,传递,179,574
对象的成员,传递给子程序,
574
访问,参见:访问子程序
复杂度度量,458
复杂度降低的好处,164
覆盖,156
覆盖后没做任何操作,
146-147
高质量,反例,161-163
公用子程序,使用接口,141
功能的内聚性(functional
cohesion),168-169
规格说明示例,221
过程命名的指导建议,172
过程上的内聚性,170
函数,特别考虑的问题,
181-182
核对表,185,774,780
黑盒(blackbox)测试,502
宏,参见:宏子程序
后条件,221
检查错误,230-231
检查伪代码,224-225
简单,有用,166-167
接口语句,226
局限性,注释,808
具名参数,180
考虑效率问题,165,222-223
可覆盖的子程序与不可覆盖
的子程序,145-146
"可移植性"的好处,165
类的子程序创建步骤,217
类似的参数,顺序,176
临时的内聚性(temporal
cohesion),169
流浪数据,567
逻辑上的内聚性(logical
cohesion),170
命名,171-173,222,277-278,
567
内聚性(cohesion),168-171
内聚性带来的可靠性,168
索 引
代码大全(第2版)
944
内联子程序,184-185
耦合的注意事项,100-102
契约式设计,233
前条件,221
嵌套层次很深,164
强度,168
巧合的内聚性,170
设计,86,220-225
设置代码,重构,568,569
声明,226
事件处理器,170
收尾步骤,232
输入-修改-输出的参数顺序,
174-175
数据的状态,509
数据结构,224
顺序上的内聚性(sequential
cohesion),168
说明,178,180
算法选择,223,573
缩进,766-768
"通过子程序隐藏指针"的好
处,165
通信上的内聚性
(communicational
cohesion),169
头部注释(header comment),
223
伪代码编写步骤,223-224
伪代码变为高层次的注释,
226-227
文件,布局,772
先决条件,221
相似,重构,574
向下转型(down cast)的对象,
574
消除错误,231
小型子程序与大型子程序作
比,166,173-174
行尾布局,767
要点,186,234
"以对象作为参数"的抽象,
179,574
"隐藏顺序"的好处,165
用函数完成计算之示例,
166-167
在脑海中检查程序中的错误,
230
"支持子类化"的好处,165
重复步骤,232
重复的好处,164-165
重构,229,573-575,578,
582
重要性,163
注释,805-809,817
转到伪代码编程过程,
232-233
转换为类,准绳,573
子程序返回,多处返回,
391-393
"子程序规模"作为重构指
示,565-566
子程序命名的描述性指导建
议,171
子程序内部的设计,87
子程序中的错误,对长度而
言,173
子程序中的多处返回,
391-393
子程序中的空行,766
走查(walk-through)代码,
231
子程序的参数
C语言函数库参数顺序,175
Java语言,176-177
Visual Basic语言,180
按引用传递与按值传递,333
变量,用作参数,176-177
"参数列表规模"作为重构指
示,566
常量前缀,176,177,274
抽象和对象参数,179
出错变量,176
传递,类型,333
创建in关键字,175-176
创建out关键字,175-176
对象,传递,179
个数,限制,178
核对表,185
结构型参数,322
枚举类型,303
命名,178,180,274,277,
278,279
全局变量,336
确保实际参数与形式参数相
匹配,180
实际参数,与形式参数匹配,
180
使用所有参数的规则,176
输入-修改-输出的顺序,
174-175
顺序,174-176
说明,178
行为取决于参数的子程序,
574
形式参数,与实际参数匹配,
180
依赖关系,明确,349
在子程序中使用的指导原则,
174-180
指针的星号(*)规则,334-335
重构,571,573
注释,806-807
状态,176
子程序中的多处返回,391-393
子过程,161;参见:子程序
子系统设计层,82-85
字符(character)数据类型
C语言,299-301
Unicode,298,299
核对表,316-317
神秘的(字面(literal))字符 ,
297-298
数组与字符串指针,299
转换(conversion)策略,299
字符集(character set),298
字符串(string)数据类型
C语言,299-301
Unicode,298,299
本地化(localization),298
初始化,300
核对表,316-317
神秘的(字面(literal))字符
串,297-298
索引,298,299-300,627
与内存有关的问题,298,300
指针与字符数组,299
转换(conversion)策略,299
字符集(character set),298
字符串指针,299
字符数组(character array),299-300;
参见:字符串数据类型
字面量(literal)数据,297-298,
308-309
自上而下的集成,694-696
自动化测试(automated testing),
528-529
自然形成的本质,设计过程,76
自上而下的设计方法,111-113
自说明代码(self-documenting
code),778-781,796-797
自下而上的集成,697-698
自下而上的设计方法,112-113
走查(walk-through),492-493,
495-496
组合(Composite)模式,104
组件(components),购买,18,51
组件测试(component testing),499
最大的正常局面(maximum normal
configuration),515
最小的正常局面(minimum normal
configuration),51
索 引
代码大全(第2版)
945
索 引
代码大全(第2版)
946
索 引
代码大全(第2版)
947
索 引
代码大全(第2版)
948
代码大全(第2版)
915
Ⅱ 中文索引
(符号/数字/字母)
&(指针引用符),332
*(指针声明符),332,334-335,763
->(指针符),328
0,除以0,292
80/20法则,592
Ada语言
参数顺序,174-175
介绍,63
ADT(Abstract Data Type),参见:
抽象数据类型
auto_ptrs,333
Basic语言,65;参见:Visual Basic
BCD(binary coded decimal,二进制
编码的十进制)类型,297
BDUF(Big Design Up Front,预先
做大量的设计),119
begin-end,742-743
break语句
while循环,379
带标号的(labeled),381
简化嵌套的if语句,446-447
一个循环中出现多次,380
在C++语言中退出循环,
371-372
指导建议,379-380
注意事项,381
Bug,参见:调试,代码中的缺陷,
错误
build工具,716-717;参见:编译器
C#语言,64
C++语言
DoNothing()宏,444-445
布尔表达式(boolean
expression)语法,442-443
参考资源,159
参数,按引用传递(by
reference)与按值传递(by
value),333
调试存根(debugging stubs),
208-209
断言(assertion)示例,191
副作用(side effects),759-761
宏(macro),182-184
接口(interface)所需的考虑
事项,139-141
介绍,64
空语句,444-445
命名约定,275-277
内联(inline)子程序,184-185
推荐的布局(layout),745
异常(exceptions),198-199
预处理器(preprocessors),排
除调试代码,207-208
源文件的布局(layout),773
指针(pointer),325,328-334,
763
CASE(Computer Assisted Software
Engineer,计算机辅助软件工程)
工具,710
case语句
default子句,363
按数字顺序排列,361
按执行频率(frequency of
execution)排列,361,
612-613
按字母顺序排列(alpha
ordering),361
编程语言的支持,361
表驱动法(table-driven
methods),421-422
重构(refactoring),566,573
重新设计(redesigning),453
错误检测,363
改用多态(polymorphism),
147-148
行尾布局(endline layout),
751-752
核对表,365
简化动作的指导建议(simple
action guideline),361
刻意制造的变量(phony
variables),361-362
末尾的case语句,363-365
调试,206
要点,366
与if语句的性能比较,614
越过(drop-through)case的
末尾,363-365
正常情况置先(normal case
first)原则,361
转换为嵌套的if语句,
448-449,451
组织各种情况(case)的顺序,
361
做相同的修改(parallel
modifications to),566
CMM(能力成熟度模型),491
Cobol语言,64
const关键字,C++中,176,177,
243,274,333
continue语句,379,380,381
CRC(类,职责,合作者)卡片,118
Currency(货币)数据类型,297
C语言
布尔表达式(boolean
expression)语法,442-443
抽象数据类型(ADT),131
介绍,64
命名约定(naming
conventions),275,278
指针(pointers),334-335
字符串(string)数据类型,
299-301,317
字符串索引(string index)错
误,299-300
Debug.Assert(断言调试)语句,
191-193
Decorator模式(Decorator pattern),104
Delphi示例,以汇编语言重写
(recoding to assembler),640-642
Demeter原则,150
diff工具,556,712
DoNothing()宏,444-445
do循环,369-370;参见:循环
DRY(Don't Repeat Yourself,不要重
复自己)原则,565
else子句
常见情况置先(common cases
first)原则,359-360
调用布尔函数(boolean
function)进行判断,359
判断链(chains),358-360
空语句(null statement),358
用case语句代替,360
用默认情况覆盖所有情况
(default for covering all
cases),360
与goto语句共用,406-407
正确性测试(correctness
testing),358
Exit Function语句,391;参见:return
语句
Exit Sub语句,392-393;参见:return
语句
Exit语句,参见:break语句
finally语句,404-405
final关键字,Java语言,243
foreach循环,367,372
Fortran语言,64
for循环
格式化(formatting),732-733,
索 引
代码大全(第2版)
916
746-747
目的,372
下标(index),377-378
优点,374
goto语句
比较若干替代方案,405
布局(layout)指导建议,
750-751
参考资源,409-410
重写代码的琐碎示例,
400-401
共享else子句中的代码,
406-407
合理使用,407-408
核对表,410
可读性问题(readability
issues),398
缺点,398-399
缩进问题(indentation
problem),398
未用到的标号(unused
labels),408
无谓的辩论(phony
debating),400-401
向前跳转(forward direction)
的指导建议,408
要点,410
用try-finally结构重写,
404-405
用嵌套的if语句重写,
402-403
用于错误处理,401-402
用于释放资源(deallocation),
399
用于消除重复代码,399
用状态变量(status variables)
重写,403-404
优点,399
优化问题(optimization
problem),398
在Ada语言中,399
在Fortran语言中,399
指导建议,407-408
grep工具,711
GUI(Graphic User Interface),
参见:图形用户界面
I/O(Input/Output),参见:输
入/输出
IDE(Integrated Development
Environment),参见:集成
开发环境
IEEE(电子与电器工程师协会),813
if语句
else子句,358-360,406-407
常见情况置先(common cases
first)原则,359-360
重构,573
从嵌套if语句的多处返回,
392-393
错误处理(error processing)
示例,356-357
单语句布局,748-749
颠倒顺序,358
调用布尔函数(boolean
expression)进行判断,359
覆盖所有情况,360
核对表,365
后续行,757
简单的(plain)if-then语句,
355-357
简化,445-447
将其中的否定(negative)判
断转换为肯定(positive)判
断,435-436
空的if子句,357
类型,355
嵌套,参见:嵌套的if语句
提取到子程序中,449-451
替代查询表(lookup table),
614-615
相等(equality)情况时的分
支(branching),355
要点,366
以频率(frequency)的顺序进
行判断,612-613
用break语句块简化,446-447
用表(table)替代,413-414
用其重写含有goto语句的代
码,402-403,406-407
与case语句的比较,360,614
语句串,358-360
正常路径置先(normal path
first)原则,355
正常情况置先(normal case
first)原则,356-357
转换为case语句,448-449,
451
转换为if-then-else语句,
447-448
in关键字,自行创建,175-176
Javadoc,807,815
JavaScript语言,65
Java语言
变量的持续性(persistence),
251
布尔表达式(boolean
expression)语法,443
布局(layout)建议,745
参考资源,159
参数(parameter)示例,
176-177
断言(assertion)示例,190
介绍,65
命名约定,276,277
生存时间(live time)示例,
247-248
异常(exception),198-201
JUnit,531
lint工具,557
Liskov替换原则(LSP),144-145
LSP(Liskov Substitution Principle),
参见:Liskov替换原则
Macintosh命名约定,275
McCabe的复杂度量度(complexity
metric),457,458
mock对象,523
null对象,重构,573
null语句,444-445
Observer(观察者)模式,104
Pareto法则,592
Perl语言,65
PHP语言(PHP: Hypertext Processor,
PHP:超文本处理器),65,600
Python语言
介绍,65
性能问题,600
return语句
参考资源,408
从子程序的多处返回,
391-393
防卫子句(guard clauses),
392-393
核对表,410
可读性(readability),391-392
要点,410
SCM(Software Configuration
Management,软件配置管理),
665;参见:配置管理
SDF(Software Development Folder,
软件开发文件夹),778
Set()子程序,576
sizeof(),335
strcpy(),301
strncpy(),301
struct关键字,参见:结构体
switch语句;参见:case语句
Tacoma Narrows大桥坍塌,74
try-finally语句,404-405
T型集成(T-Shaped integration),701
UDF(Unit Development Folder,单
元开发文件夹),778
UDT(User-Defined Type,用户自定
义类型)
缩写,279-280
UML(Unified Modeling Language,
统一建模语言)图(diagram),118,
120
Unicode,288-299
索 引
代码大全(第2版)
917
UNIX编程环境,720
Visual Basic语言
参考资源,159
参数(parameter)示例,180
大小写不敏感
(case-insensitivity),273
断言(assertion)示例,192-194
关闭隐式声明(implicit
declaration),240
结构体(structure),320-322
介绍,65
块风格(blocking style),738
枚举类型(enumeration type),
303-306
命名约定,278-279
推荐布局,745
异常(exception),198-199,
202
while循环
break语句,379
do-while循环,369
出口(exit),369-372
对判断(evaluation)的误解
(misconception),554
检测,所处位置,369
空语句,444
目的,368
无限循环(infinite loops),374
优势,374-375
Wiki(维基),117
WIMP(为什么Mary不在编程 !)
综合症,26
WISCA(为什么Sam不在写代
码 !)综合症,26
(A)
安全性,47
安装工具,718
(B)
白盒测试(whitebox testing),500,502
版本控制(version control)
工具,668,715
移除调试辅助代码,207
注释,811
绑定(binding)
编译时(compile time),
252-253
变量的绑定时间,252-254
代码中,252
即时(just in time),253
加载时(load time),253
启发式(heuristic)设计,107
要点,258
运行时(run time),253
包,156-157
包含(containment),88,143
报告,参见:正式检查
备份计划(backup plans),669,670
本地化
架构的前期准备,48
字符串数据类型,298
本质的问题(essential problems),
77-78
比较(comparisons)
布尔(boolean),参见:布尔
测试
浮点数等量判断(floating-point
equality),295-296
混杂的(mixed)数据类型,
293
边界值分析(boundary analysis),
513-514
编程的信仰态度(religious attitude)
布局风格成为信仰,735
管人,683-684
软件先知(software oracles),
851
与试验(experimentation)相
比,852-853
折中主义(eclecticism),
851-852
编程工具
build工具,716-717
diff工具,712
grep工具,711
merge工具,712
版本控制(version control)工
具,715
编辑器,710-713
编译器(compiler),716
参考资源,724
测试工具,719
尺度报告器,714
重构器(refactorer),714-715
打造自己的编程工具,
721-722
代码调整,720
代码库,717
代码生成向导,718
多个文件中查找字符串,
711-712
翻译器(translator),715
反汇编器(disassembler),720
工具导向的(tool-oriented)环
境,720-721
核对表,724-725
幻境(fantasyland),722-723
汇编代码清单生成(assembler
listing)工具,720
集成开发环境(IDE),710-711
计算机辅助软件工程(CASE)
工具,710
交叉引用(cross-reference)工
具,713
脚本(script),722
接口文档,713
结构改组(restructurer)工具,
715
可执行代码(executable-code)
工具,716-720
类的继承体系生成器(class
hierarchy generator),713
链接器(linker),716
美化器(beautifier),712
模板(template),713
目的,709
设计工具,710
数据字典(data dictionary),
715
调试工具,526-527,545,
558-559,719
图形化的设计工具,710
项目特有的工具,721-722
要点,725
依赖关系检查器(dependency
checker),716
语法(syntax)检查器,713-714
语义(semantic)检查器,
713-714
预处理器,718-719
源代码工具,710-715
执行剖测器(execution
profiler),720
质量分析,713-714
编程狂人(gonzo programming),832
编程方面的期刊(periodicals),
859-860
编程语言选择
Ada语言,63
Basic语言,6
C#语言,64
C++语言,64
Cobol语言,64
C语言,64
Fortran语言,64
JavaScript语言,65
Java语言,65
Perl语言,65
PHP语言,65
Python语言,65
SQL语言,65
Visual Basic语言,65
表达概念,63
高级语言与低级语言的生产
率,62
汇编语言,63
深入语言去编程(programming
索 引
代码大全(第2版)
918
into language),68-69,843
生产率来源,62
熟悉的语言与不熟悉的语言,
62
思维,影响,63
相对于C语言的等级,表格,
62
重要性,61-63
编程约定(convention)
编码实践的核对表,69
格式化规则,参见:布局
选择,66
编辑工具
diff工具,712
grep工具,711
merge工具,712
多个文件中查找字符串,
711-712
集成开发工具(IDE),710-711
交叉引用(cross-reference)工
具,713
接口文档(interface
documentation),713
类的继承体系生成器(class
hierarchy generator),713
美化器(beautifier),712
模板,713
编码(coding);参见:构建;软件
构建概述
风格(style);参见:布局
软件构建,5
实践核对表,69
序列式(sequential);参见:
直线代码
约定;参见:编码约定
编码的"写作隐喻(writing
metaphor)",13-14
编码约定(convention)
风险(hazard)规避,844
格式化(formatting);参见:
布局
好处,844-845
核对表,69
可预期的好处,844
编译器(compiler)
编译时绑定,252-253
在子程序中寻找错误,
230-231
把调试工具当作编译器,557,
827
多条出错信息,550
富于技巧的(tricky)代码优
化,597
工具,716
警告(warnings),293,557
破损的(broken)build,703
适合整个项目的标准,557
数据类型警告,293
信息,对待,549,826-827
行号,用以调试,549
性能调整的考虑,590
验证器,231
优化,596-597
优化的速度,表格,597
变更控制(change-control),参见:
配置管理
变量(variable)
绑定时间(binding time),
252-254
变化,标识区域,98-99
变量类型;参见:数据类型
持续性(persistence),251-252
重构,571,576
重用,255-257
初始化(initialization),
240-244,257
存活时间,246-248,459
迭代数据,255
公用类成员,576
混合耦合,256-257
计数器,243
就近原则,242
局部化引用,245
跨度,245
命名;参见:变量名
全局变量;参见:全局变量
声明变量;参见:声明
使用变量的核对表,257-258
使用所有已声明的变量,257
数据类型与控制结构之间的
关系,254-255
数据认知测试,238-239
序列型数据,254
选择型数据,254
循环变量,382-384
要点,258
隐含含义,避免,256-257
隐式声明,239-240
注释,803
作用域;参见:变量的作用域
变量的持续性(persistence),
251-252,831
变量的存活时间(lifetime),246-248,
459
变量的作用域(scope)
把相关语句放在一起,
249-250
变量跨度,245
变量名,影响,262-263
变量引用局部化,245
存活时间,最短化,246-248
定义,244
"方便性"论据,250
赋值,249
"可管理性"论据,251
全局作用域,问题,251
限制与扩展策略,250
循环初始化,249
要点,258
语言差异,244
最小化,指导原则,249-251
变量名
C++语言,263,275-277
C语言,275,278
Java命名规则,277
Visual Basic语言,279
保留的名字,287
布尔变量,268-269
长度,最适当的,262
常量,270
大小写,286
对仗词,264
多种自然语言,287
核对表,288-289
计算值限定词(computed-value
qualifiers),263-264
精确描述的原则,260-261
类成员变量,273
类型名,区分,272-273
良好的变量名,示例,260,
261
临时变量,267-268
枚举类型,269
名字的相似处,过多,285
命名空间(namespace),263
目的,240
拼错单词,286
全局,限定词,263
数字,286
缩写的指导原则,282
特征性原则,261
同音异义字,286
完全描述的原则,260-261
心理距离,556
信息分类,277
循环下标(loop index),265
要点,289
以问题为导向的原则,261
语音(phonic)缩写,283
"糟糕的变量名"示例,
259-260,261
状态变量,266-267
子程序名,区分,272
字符,易混淆,287
作用域,影响,262-263
变量名长度,最适当的,262
变量名的对仗,264
索 引
代码大全(第2版)
919
标记,缺陷,787
标志(flag)
goto语句,重写,403-404
变更,标明区域,98-99
枚举类型(enumerated type),
266-267
名称,266-267
语义耦合(semantic
coupling),102
注释标志位的含义(bit-level
meanings),803
标准,概述,814
表达式(expression)
布尔(boolean),参见:布尔
表达式
布局指导建议,749-750
常量,数据类型,635
初始化,编译时,632-633
公共表达式的消除
(subexpression
elimination),638-639
强度削减,630-632
系统调用的性能,633-634
右移(right shifting),634
预先计算的结果
(precomputing results),
635-638
表驱动法(table-driven method)
case语句法,421-422
保险费率示例,415-416
查询问题,412
从表达式创建,435
存放问题,413
代码调整,614-615
定义,411
对象法,422-423
二分查找(binary search),428
构造键值,423-424
核对表,429
键值,423-424
阶梯访问表,426-429
例子:灵活的消息格式,
416-423
目的,411-412
其他示例,429
区间的端点,428
设计方法,420
示例:一月中的天数,413-414
索引访问表,425-426,428-429
问题,412-413
要点,430
优点,420
预先计算某些运算,635
直接访问;参见:直接访问表
转换键值,424
别名(aliasing),311-316
不成熟的优化,840
不要重复自己(DRY,Don't Repeat
Yourself)原则,565
布尔变量(boolean variables)
C语言,创建数据类型,
302-303
标识符,431-433
表达式,参见:布尔表达式
核对表,317
简化判断,301-302
枚举类型作为替代方案,304
命名,268-269
文档,301
以0和1为值,432
布尔表达式(boolean expressions)
C语言语法,442-443
if语句中的否定,435-436
Java语法,439,443
把0和1作为值,432
比较时常量的位置,442-443
变量,参见:布尔变量
标识符,431-433
布局指导建议,749-750
拆分为多个部分判断,433
重构,572
狄摩根定理(DeMorgan's
Theorems)的应用,436-437
短路求值(short circuit
evaluation),438-440
否定,435-437
函数,移入,434-435
核对表,459
简化,433-435
决策表(decision tables),移
入,435
肯定(positive form)形式,
建议,435-437
括号用以明示,437-438
逻辑恒等式(logical
identities),630
求值的指导建议,438-440
数值,结构,440-441
隐式比较(implicit
comparisons),433
与0比较,441-442
指针,比较,441
字符,与0比较,441
布尔函数(boolean functions)
if语句,用于,359
从表达式创建,434-435
布尔判断(boolean tests)
拆分为多个部分判断,433
简化,301-302
用子程序隐藏,165
与0比较,441-442
布局(layout)
begin-end,742-743
begin-end两次缩进,746-747
C++中的副作用,759-761
goto,750-751
Visual Basic的块风格,738
不完整的语句,754-755
纯块风格(pure blocks style),
738-740
代码中的文档说明,763-766
单语句代码块,748-749
对特定语言的布局建议,745
风格概述,738
负面示例,730-731
复杂表达式,749-750
赋值语句后续部分,758
格式化的基本原理,732
行尾布局,743-745,751-752
核对表,773-774
花括号的布局风格,734,
740-743
会引起误导的缩进示例,
732-733
会引起误导的优先级计算顺
序,733
接口,768
结构风格,重要性,733-734
紧密关联的语句元素,
755-756
可读性目标,735
空白,732,736-737,753-754
空行,737,747-748
控制结构的布局风格,
745-752
控制语句的后续行,757
括号,738
类,768-771
论述的规矩,733
逻辑表达式,753
逻辑结构,展现,732,735
每行有多条语句,758-761
模仿纯块结构(emulating pure
blocks),740-743
目标,735-736
普通布局的示例,731-732
声明,761-763
始终如一的要求,735
数组引用,754
缩进(indentation),737
违背良好编程风格,注释,801
未缩进的begin-end对,746
文件,内部,771-773
信仰方面,735
修改建议,736
续行的结尾,756-757
要点,775
索 引
代码大全(第2版)
920
语句长度,753
语句的后续行,754-758
语句接续,754-758
语句块的布局风格,738-743
指针,C++,763
注释,763-766
资源,774-775
子程序的布局原则,766-768
子程序调用语句的后续行,
756
子程序实参(routine
argument),754
自说明代码(self-documenting
code),778-781
(C)
操作,常见操作的开销,601-603
操作系统,590
测试(test)
diff工具,524
JUnit,531
把错误的发生稳定下来,542
白盒(white-box)测试,500,
502
保留测试记录,529-530
笔误(拼写错误),519
边界检查工具,527
边界值分析,513-514
标准,IEEE,532
猜测错误,513
采用多种不同的方法,545
采用容易检查的测试用例,
516
测试本身的错误,522
测试数据生成器,524-525
测试先行或后行的建议,
503-504,531
测试先行开发(test-first
development),233
测试影响不到的特性,501
测试用例(test case),创建,
506-508,522-525,532
测试用例的错误,522
测试在软件质量中的角色,
500-502
从开发者角度测试的局限性,
504
"存在错误"假设,501
错误的分类,518-520
错误的影响范围,519
错误检查表,503
错误数据库,527
大多数错误都很容易修正,
519
代码覆盖,505-509,526
"代码覆盖"测试,506
单元(unit)测试,499,545
等价类划分(equivalence
partitioning),512
符号调试器,526-527
复合边界值,514
覆盖率优先级排序,505
干净测试的局限,504
工具,清单,719
构建范畴之外的错误,519
构建中测试,502-503
构建中的缺陷,比例,520-521
核对表,532
黑盒(black-box)测试,500
回归(regression)测试,500,
528
集成(integration)测试,499
几类好数据,515-516
几类坏数据,514-515
计划,528
脚手架(scaffolding),
523-524,531
结构化基础测试,503,
505-509
旧数据,兼容性,516
开发测试,522
开发者测试的局限性,504
可测试性,465,467
框架,522,524
乐观程序员的限制,504
量化,520,529
"逻辑覆盖"测试,506
模仿对象,527
目标,501
内存工具,527
期望的错误发生率,521-522
驱动函数(driver routine),523
惹人厌烦的特性,501
日志记录器,526
容易出错的类,517-518
设计,错误理解,519
设计要点,503
数据记录工具,526
数据流测试,509-512
随机数据生成器,525
调试,与测试对比,500
调试器,526-527
推荐方法,503-504
系统测试,500
系统干扰器,527
相关资源,530-531
需求,503
哑类(dummy classes),523
哑文件(dummy files),524
要点,533
"已定义-已使用"的数据路
径,510-512
用于测试的结果,502
占据的时间,501-502
正常情形的错误,515
正确性的可证明性,501,505
桩对象(stub object),523
子程序,黑盒测试,502
自动化测试,528-529
组件(component)测试,499
最大的正常局面,515
最小的正常局面,515
测试数据生成器,524-525
测试先行开发,233
策略模式,104
层次性设计目标,81
"差一"(off-by-one)错误
边界值分析(boundary
analysis),513-514
修改方法,553
忏悔式调试(confessional
debugging),547-548
常量(constants)
重构,571
初始化,243
定义,307
核对表,317
命名,270,273,277-279
模拟,309
目的,307
声明,308
一致性原则,309
由全局变量模拟,338
字面量,避免(literals,
avoiding with),308-309
超越函数,602,634
成熟的技术环境,67
诚实,826-828
程序规模,参见:项目规模
程序流
控制,参见:控制结构
序列式,参见:直线型代码
程序员,看待,参见:团队
分配时间,681
风格问题,683-684
概述,680
私密的办公室,684
物理环境,684-685
相关资源,685-686
信仰问题,683-684
性能差异,681-683
程序员,性格,参见:性格,个人
程序员所处的物理环境,684-685
程序组织的先决条件,45-46
持续集成(continuous integration),706
尺度报告器(metric reporter),714
索 引
代码大全(第2版)
921
重复(duplication)
避免,借助子程序,164-165
代码,作为重构指标,565
重构(refactoring)
80/20法则,582
case语句,573
DRY(不要重复自己)原则,
565
GUI(图形化用户界面)数据,
576
if语句,573
null对象,573
PPP(伪代码编程过程)编码
步骤,229
"安全重构"的指导建议,
579-581,584
把要做的事情一条条列出来,
580
备份老代码,579
变量,571
表达式,571
布尔表达式,572
参数,566,571,573
测试,580
策略,582-584
查询,574
代码调整,与重构作比,609
"代码重复"的指示,565
单向的类联系,577
单元测试,580
定义,565
对象,574-576
风险级别,581
复杂模块,583
工具,714-715
公用数据成员,567
构造函数改为工厂方法
(Factory Method),577
规模的指导建议,580
过多使用基本数据类型,567
核对表,570,577-579
基类,575
记录,572
检查,580-581
检查点,580
接口,566,575-576,579
警告信息,编译器,580
拒绝重构的理由,571
滥用,582
类,566-567,574-576,
578-579,582
类的数据类型,572
类接口,575-576
类内聚性的指示,566
流浪数据(tramp data),567
派生类,567,575
派生类间的不同常量,574
全局变量,568
缺陷,修补,582
群集,572
设计供将来某个时候用到的
代码,569-570
设置代码,568-569
收尾代码,568-569
数据级,571-572,577
数据设置,相对,指示,566
数组,572
双向的类联系,577
算法,573
条件表达式,573
"同一时间只做一项重构"原
则,580
无法控制来源的数据,576
系统级,576-577,579
相关资源,585
循环,565,573
要点,585
"要求多个相同修改"的指
示,566
易于出错的模块,582
引发的维护,583
引用对象,574
语句级,572-573,577-578
增加子程序,582
"中间人(middleman)"类,
567
重新设计而非重构,582
注释于拙劣代码,568
拙劣代码,接口,583-584
子程序,565-567,573-574,
578,582
字面形式表示的常量,571
重新测试,参见:回归测试
抽象(abstraction)
不好的类接口的示例,
134-135
不一致,135-136,138
层次,845-847
成对的操作,137
抽象数据类型;参见:抽象数
据类型
创建类接口的指导建议,
135-138
定义,89
访问器(accessor)子程序,
340-342
复杂度(complexity),839
高层问题域中的术语,847
好的类接口的示例,133-134
核对表,157
接口,抽象的目标,133-138
类,152,157
力求精确(exactness goal),
136-137
模式(pattern),103
内聚性(cohesion),138
评估,135
气锁阀(air lock)的比喻,136
实现结构,底层,846
问题域中的术语(problem
domain term),底层,846
形成一致的抽象,89-90
修改时破坏抽象,138
一致的类接口抽象层次,
135-136
在编程语言层次上
(programming-language
level),846
在操作系统的层次上,846
在继承树中的放置位置,146
子程序(routine),164
抽象工厂(Abstract Factory)模式,104
抽象数据类型(ADT)
把底层数据类型当成抽象数
据类型,130
把文件当成抽象数据类型,
130
操作示例表,129-130
抽象,130
代表什么的问题,130
定义,126
独立于存储介质,131
对象,130
多重实例的处理方法,
131-133
访问器子程序,339-342
改动不会扩散的好处,128
基于抽象数据类型的类,133
简单事物当作抽象数据类型,131
接口,提供更多信息,128
冷却系统的示例,129-130
目的,126
实例化,132
使数据传递最少,128
使用非面向对象语言,
131-133
数据的含义,126
文档的好处,128
显式地实例化,132
性能提升,128
需要抽象数据类型的例子,
126-127
验证代码的好处,128
益处,126-129
隐藏信息,127
隐式地实例化,132
真实世界中的实体(entities),
128-129
索 引
代码大全(第2版)
922
指导建议,130-131
出错信息(error messages)
代码,返回,195
设计,49
显示,196
友好出错信息的指导建议,
210
初始化变量
C++示例,241
Java示例,242-243
Visual Basic示例,241-242
编译器设置,243
不恰当初始化的后果,240
参数合法性,244
常量,243
重新初始化,243
第一次使用的建议,241-242
核对表,257
计数器,243
建议使用const,243
建议使用final,243
就近原则,242
类成员,243
累加器,243
全局变量,337
声明时的建议,241
系统干扰器,测试,527
修复缺陷,553
循环,其中用到的变量,249
要点,258
在靠近第一次使用变量的位
置声明和定义变量,
242-243
指针问题,241,244,325-326
重要性,240-241
字符串,300
初始化工作内存,244
除法(division),292-293
传递参数,333
创建out关键字,175-176
创造力的重要性,829,857
纯块布局风格,738-740
聪明,在性格中之角色,821
存根用来辅助调试,208-209
存根用来辅助集成,694,696
错误;参见:代码中的缺陷;异常
goto语句,用于处理,401-402
编码,参见:代码中的缺陷
处理,参见:错误处理
分类,518-520
根源,表,518
狗牌字段(dog tag fields),
326-327
异常;参见:异常
错误,猜测,513
错误处理,参见:异常
重构,577
传播(propagation)的设计,
49
错误处理子程序,调用,196
错误码,返回,195
断言(assertion),比较,191
返回中立值(neutral value),
194
防御式编程(defensive
programming),技术,
194-197
高层设计的影响,197
隔栏(barricades),203-205
关闭系统,196
缓冲区溢出(buffer overrun)
的威胁,196
记录警告信息,195
架构的前期准备,49-50
局部处理,196
可靠性(robustness),51,197
前次答案,重用,195
下一有效数据,返回,195
消息,49,195-196,210
验证设计,50
子程序,设计,222
最接近的合法值,195
错误检测,及早进行,29-30
错误码,195
(D)
大爆炸集成(big-bang integration),
691
大桥坍塌(bridge failure,Tacoma
Narrows),74
代码调整(code tuning)
80/20法则,592
DES示例,605-606
Pareto法则,592
比较逻辑结构,614
编译器方面的考虑,590,
596-597
表达式(expression),630-639
操作系统方面的考虑,590
测量以定位热点(hot spots),
603-604,644
查询表(lookup table),
614-615,635
常见操作的开销,601-603
乘法,改为加法,623-624
重构,比较,609
初始化,在编译时,632-633
从程序需求的角度看,589
代码中的缺陷(defect),601
代码行数,使之最少,593-594
代数恒等式(algebraic
identities),630
低级语言,重新编码为,
640-642
低效的根源,598-601
迭代(iteration),608,850
定义,591
短路求值(short-circuit
evaluation),610
惰性求值(lazy evaluation),
615-616
反汇编器,720
方法总结,606
分页(paging)操作,599
改进的可能性,605
概述,643-644
工具,720
功能细节,595
合并循环(jamming loops),
617-618
何时调整,596
核对表,607-608,642-643
缓存(caching)数据,628-629
汇编代码,列清单工具,720
汇编语言,重新编码为,
640-642
将判断外提后的循环
(unswitching loops),
616-617
解释型语言与编译型语言,
592,600-601
逻辑操作(logic manipulation)
的指导建议,610-616
内存操作还是文件操作,
598-599
内联子程序,639-640
频繁使用的代码,592
频率,作为测试顺序,612-613
嵌套循环的顺序,623
强度削减(strength
reduction),623-624,
630-632
缺点,591
哨兵测试(sentinel test),循
环,621-623
设计的视角看,589-590
使循环内的工作最少,
620-621
输入/输出,598-599
数据变换(data
transformations),624-629
数据库索引(indexing),601
数据类型的选择,635
数组(array),593-594,
603-604,625-627
诉求(appeal of),591-592
速度的重要性,595-596
随时随地优化,594-595
索 引
代码大全(第2版)
923
索引数据(indexing data),
627-628
无稽之谈(old wives' tales),
593-596
系统调用,599-600,633-634
消除公共子表达式
(subexpression
elimination),638-639
循环,616-624
循环展开,618-620
要点,608,645
硬件方面的考虑,591
优点,591
右移(right shifting),634
鱼和熊掌,595
语言细节,644
预先算出的结果,635-638
运算速度,假定,594
找出瓶颈,594
针对环境的变化进行调整,
594
整数优于浮点数,625
正确性的重要性,595-596
执行剖测器(execution
profiler)工具,720
转换数据类型,635
资源,606-607,644-645
资源目标(resource goals),
590
子程序,590,639-640
代码覆盖率测试(code coverage
testing),506
代码库(code libraries),222,717
代码生成向导(code-generation
wizards),718
代码阅读方法(code reading
method),494
代码质量分析工具,713-714
代数恒等式(algebraic identities),
630
单点控制,308
单件属性(singleton property),强制,
104,151
单进单出(FIFO,First-In First-Out)
的控制结构,454
单语句代码块,748-749
单元测试(unit testing),499
单元开发文件夹(UDF,Unit
Development Folder),778
等价类划分(equivalence
partitioning),512
狄摩根定理(DeMorgan's
Theorems),436-437
递归(recursion)
安全计数器,396
定义,393
核对表,410
留心栈空间,397
迷宫示例,394-396
排序示例,393-394
替代方案,398
停止递归,396
限制到一个子程序内,396
要点,410
用递归计算斐波纳契
(Fibonacci)数列,397-398
用递归计算阶乘,397-398
指导建议,394
迭代(iteration),代码,参见:循环
foreach循环,368,372
迭代器(Iterator)模式,104
迭代器循环,定义,367
迭代型数据,255
结构化编程的概念,456
迭代在开发中
代码调整,850
极限编程,58
前期准备,28,33-34
设计实践,111-117
伪代码成分,219
选择,理由,35-36
与序列式开发法的比较,
33-34
重要性,850-851
定义变量,参见:声明
定制,创建隐喻,18
度量(measurement)
反对的争论,678
副作用,678
目标,679
识别出"局外人(outlier)",
679
优点,677
有用度量类型的表格,
678-679
资源,679-680
短路求值(short-circuit evaluation),
438-440,610
断言(assertion)
C++示例,191
Java示例,190
Visual Basic示例,192-194
创建自己的机制,191
从代码中移除,190
错误处理,191,193-194
定义,189
后条件(postcondition)验证,
192-193
其中的可执行代码,191-192
前条件(precondition)验证,
192-193
实参(argument),189
危险的使用方法示例,192
依赖性(dependency),检查,
350
益处,189
应检查的假定,清单,190
与隔栏(barricade)的关系,
205
指导建议,191-193
中止程序,建议,206
资源,212
对代码签字(signing off on code),663
对数(logarithm),632-634
对系统的依赖性,85
对象(object)
protected接口,设计,89
包含,辨识,88
辨识,88
参数,用作,179,574
操作,辨识,88
重构,574-576
抽象数据类型(ADT),130
单件属性(singleton
property),强制,151
工厂方法(Factory Method)
模式,103-104,452-453,
577
公用成员与私用成员的比较,
设计,89
继承,辨识,88;参见:继承
接口,设计,89;参考:接口,
类
类,比较,86
类名,区分,272-273
删除对象,206
设计步骤,87-89
现实世界,寻找,87-89
引用对象,574
职责,分配,106
属性辨识,88
对象参数耦合,101
多个文件中查找字符串,711-712
多态(polymorphism)
case语句,替代,147-148
if嵌套,转换,452-453
定义,92
与具体语言相关的规则,156
多项式(polynomial expression),
631-632
多重继承(multiple inheritance),
148-149
惰性求值(lazy evaluation),615-616
(E)
二分查找(binary search),428
(F)
发展解决问题的技能,823
索 引
代码大全(第2版)
924
法律通告(legal notices),811
翻译器工具(translator tool),715
反汇编器(disassembler),720
方法(method),参见:子程序
方法论(methodology),657-659;
参见:开发方法
防御式编程(defensive
programming)
安全问题,212
产品代码(production code)
指导建议,209-210
错误处理,194-197
导致的问题,210
调制助手(debugging aids),
205-209
定义,187
断言(assertion),189-194
隔栏(barricade),203-205
核对表,211-212
检查假定(assumption),列表,
190
健壮性与正确性(robustness
vs. correctness),197
日志的指导建议,210
稳妥崩溃的指导建议,210
细微(trivial)错误的指导建
议,209
验证输入,188
要点,213
异常,198-203,211
硬性崩溃错误的指导建议,
209
友好提示消息的指导建议,
210
质量改善技术,其他,188
重要错误的指导建议,209
访问器子程序(accessor routine)
"g_"前缀,340
抽象的层次,341-342
抽象的好处,340
创建,340
当编程语言不支持时,克服,
340-342
隔离变量带来的好处,339
集中控制,339
锁定,341
信息隐藏的好处,340
要求,340
一致化(parallelism),342
优点,339-340
非标准的语言特性,98
非正式技术复查(informal review),
467,492-493
斐波纳契数列(Fibonacci numbers),
397-398
分层结构的(hierarchy)优点,
105-106
分而治之(divide and conquer)技术,
111
分解(factoring),154;参见:重构
分析技能的培养,823
分页操作,599
风格问题
格式化;参见:布局
人为因素,683-684
自说明代码,778-781
风险导向的集成,699
封装(encapsulation)
对用户的假定,141
公用数据成员,567
核对表,158
接口中的公用子程序,141
类,角色,139-143
类的公用成员,139
类的耦合太紧,142-143
类接口中的私用细节,
139-141
启发式设计(heuristic
design),90-91
让可访问性(accessibility)最
小,139
弱的封装,567
向下转型(downcast),对象,
574
友元类(friend class),141
语义上的破坏(semantic
violation),141-142
浮点(floating-point)数据类型
Visual Basic类型,297
二进制编码的十进制数
(BCD),297
核对表,316
精度限制,295
舍入误差(rounding errors),
297
数量级(magnitudes)相差巨
大的运算,295
相等比较(equality
comparisons),295-296
运算开销,602
符号调试器,526-527
复合边界值(compound boundaries),
514
复合语句(compound statements);
参见:语句块
复杂(complex)数据类型,参见:
结构
复杂度(complexity)
McCabe度量,457-458
编码约定,用以削减,839
抽象,处理,839
范围(span),459
隔离,借助类,153
管理,77-79,844-845
决策点(decision points),计
数,458
可靠性(reliability),457
控制结构对其的影响,
456-459
类,用以削减,152
模式,用以削减,103
生存期(live time),459
问题域(problem domain),工
作在,845
项目规模的影响,656-657
应对的方法,837-839
约定,以管理,844-845
智力实体数量的测算(mental
objects held,measure of),
457
重要性,457
子程序,用以削减,164
最小化的目标,80
复审(review)
代码阅读,494
迭代法(iteration),在复审中
的位置,850
非正式,定义,467
教育(educational)方面,482
公开演示(dog-and-pony
show),495
正式,质量,467
正式检查(formal inspection),
比较,485
重构后的检查,580-581
"逐行复审代码"原则,663
走查(walk-through),492-493
副作用(side effect),C++,759-761
赋值(assignment)语句,249,758
覆盖率(coverage)
监控(monitoring)工具,526
结构化基础测试(structured
basis testing),505-509
覆盖型链接器(overlay linker),716
(G)
改善代码执行速度的核对表,642-643;
参见:代码调整,性能调整
干扰器,参见:系统干扰器
高内聚性,105
高扇入(high fan-in)的设计目标,80
格式化代码(formatting code),参见:
布局
格式化的基本定理(Fundamental
Theorem of Formatting),732
隔栏(barricade)
接口作为边界,203
类层次,204
索 引
代码大全(第2版)
925
目的,203
手术室类比(analogy),204
输入数据的转换,204
与断言(assertion)的关系,
205
个人性格(personal character)
编译器信息,对待,826-827
成功的项目,从中学习,
823-824
诚实(intellectual honesty),
826-828
创造力(creativity),829,857
错误,承认,826
分析技能(analysis skills),823
疯狂编程(gonzo
programming),832
沟通技能(communication
skills),828
估计(estimations),827-828
好奇心(curiosity),822-825
合作技能(cooperation skills),
828
计算机科学系的毕业生,829
纪律(discipline),829
坚持(persistence),831
解决问题,823
经验,831-832
懒惰,830
弥补缺陷的手段,821
判断,848
谦卑,821,826,834
试验,822-823
习惯,833-834
要点,835
阅读,824
知晓开发过程,822
智力,821
重要性,819-820
专业开发(professional
development),824-825
状态报告,827
资源,834-835
宗教信仰,有害方面,851-853
个人性格,参见:性格,个人
耕作隐喻(farming metaphor),14-15
工厂方法(Factory Methods)
重构为,577
工厂方法(Factory Method)
模式,103-104
嵌套if语句,重构示例,
452-453
工具
编程;参见:编程工具
编辑;参见:编辑工具
核对表,70
调试;参见:调试
源代码;参见:源代码工具
工具的版本控制,668
工具箱法,20
公开演示(dog-and-pony shows),495
公用数据成员,567
功能导向的集成(feature-oriented
integration),700-701
功能的内聚性(functional cohesion),
168-169
功能规格书(functional
specification),参见:需求
沟通,开发团队,650
沟通技能的重要性,828
狗牌字段(dog tag fields),326-327
构建(construction),参见:软件构
建概览
各项活动的比例,按项目规
模,654-655
工具,参见:编程工具
管理,参见:管理构建
进度估计(schedules
estimating),参见:构建进
度表,评估
决策(decision),参见:构件
的决策
前期准备(prerequisites),参
见:前期准备
项目规模带来的影响;参见:
项目规模
协作(collaborative),参见:
协作
指导建议,66
质量,参见:软件的质量
资源,856
构建,每日,参见:每日构建,冒烟
测试
构建的决策(construction decisions)
编程语言,参见:编程语言的
选择
编程约定,66-66
编码实践核对表,69
成熟的技术环境,67
工具核对表,70
核对表,主要的构建实践,
69-70
技术浪潮,确定你在其中的位
置,66-69
浪潮早期的环境,67
深入语言编程(programming
into languages),68-69
团队合作核对表,69
要点,70
质量保证核对表,70
主要构建实践的选择,69-70
构建进度表,评估(construction
schedules,estimating)
比较多种技术,672
重新估计,672
方法列表,671
概述,671
赶上,675-676
计划估计时间,671
控制还是估计,675
乐观主义(optimism),675
确立目标,671
缩小范围,676
团队扩张,676
细致程度,672
需求规格(requirements
specification),672
影响因素,674-675
资源,677
构造函数(constructor)
重构,577
初始化数据成员,151
单体属性(singleton
property),确保,151
深拷贝与浅拷贝(deep vs.
shallow copies),151-152
异常,199
指导建议,151-152
购买组件(components),18,51
估计进度(estimating schedules)
变更的成本,666
不准确,性格原因,827-828
定期重新评估,672
多种技术比较,672
方法列表,671
概述,671
控制,比较,675
扩充团队,676
乐观主义(optimism),675
目标,确立,671
缩减范围,676
为评估时间制定计划,671
细致程度,672
需求规格(requirements
specification),672
影响因素,674-675
资源,677
关键构建决策,参见:构建决策
观察者(Observer)模式,104
管理构建
变更控制,参见:配置管理
标准,IEEE,687,814
标准,权威人士设定,662
程序员,对待态度,680-686
代码所有权的态度,663
度量,677-680
对代码签字,663
索 引
代码大全(第2版)
926
方法,参见:开发方法
复查所有代码,663
复杂度,77-79
奖励好的做法,664
进度,评估,671-677
经理,686
可读性的标准,664
良好编码实践,鼓励,662-664
两人组队,662
配置管理,参见:配置管理
详查,其中的经理角色,
486-487
项目规模,影响,参见:项目
规模
要点,688
资源,687
规格说明,参见:需求
国际化,48
过程,参见:子程序
何时采用,181-182
命名的指导原则,172
过程上的内聚性,170
过度工程,51
(H)
函数(functions),参见:子程序
不允许,150
定义,181
返回值,设置,182
何时使用,181-182
计算转换位函数,示例,
166-167
命名约定,172,181
私用(private),覆盖
(overriding),146
要点,186
状态作为返回值,181
行尾布局(endline layout),743-745,
751-752,767
行尾注释(endline comments),
793-795
好奇心,在性格中的角色,822-825
好数据,测试,515-516
合并(merge)工具,712
合并循环,617-618
合法性校验
对输入参数的原则,188
对外部数据源的原则,188
检查假定,清单,190
枚举类型,304-305
数据类型,质疑,188
合作技能(cooperation skills)的重
要性,828
核对表(checklists)
case语句,365
goto语句,410
if语句,365
备份,670
编程工具,724-725
编码实践,69
变量(variable),257-258,
288-289,343-344
表驱动法(table-driven
method),429
布尔表达式(boolean
expression),459
布局(layout),773-774
参数(parameter),185
测试(testing),503,532
常量(constant),317
抽象(abstraction),157
初始化(initialization),257
代码调整(code tuning),
607-608,642-643
调试(debugging),559-561
防御式编程(defensive
programming),211-212
封装(encapsulation),158
格式化(formatting),773-774
工具,70
构建实践(construction
practices),69-70
集成(integration),707
继承(inheritance),158
架构(architecture),54-55
接口(interface),579
结对编程(pair
programming),484
结构(structure),343
控制结构(control structure),
459,773,780
类(class),157-158,233-234,
578-579,774,780
类型(type)创建,318
枚举类型(enumerated type),
317
每日构建(daily build)与冒
烟测试(smoke test),707
名称,288-289,780
配置管理(configuration
management),669-670
前期准备(prerequisites),59
清单,xxix-xxx
缺陷(defect),489,559-560
设计(design),122-123,781
数据类型(data type),316-318
数据组织(data organization),780
数组(array),317
速度,调优,642-643
条件语句(conditional
statement),365
伪代码编程(pseudocoding),
233-234
文档(documentation),
780-781,816-817
性能调整,607-608
修复缺陷(defects),560
需求(requirements),40,42-43
循环(loop),388-389
语句(statement),774
正式检查(formal inspection),
489,491-492
直线(straight-line)代码,353
指针(pointer),344
质量保证(quality assurance),
42-43,70,476
重构(refactoring),570,
577-579,584
注释(comment),774,816-817
子程序(routine),185,774,
780
字符串(string),316-317
字符(character)数据类型,
316-317
黑盒测试(black-box testing),500
宏(macro)子程序,参见:子程序
多条语句,183
命名,183,277-278
使用括号,182-183
替代方案,184
限制,184
后条件(postcondition)
验证,192-193
子程序设计,221
后续行(continuation lines),754-758
互用性,48
花括号(braces)
风格比较,734
语句块布局,740-743
坏数据的检测,514-515
缓冲区溢出(buffer overrun),196
缓存(caching),代码调整,628-629
回归测试(regression test)
diff工具,524
定义,500
目的,528
汇编语言(assembly language)
介绍,63
清单工具,720
重新编码,640-642
混合耦合(hybrid coupling),变量的,
256-257
混合体,149
混合语言环境,276
(J)
基类(base class)
索 引
代码大全(第2版)
927
Liskov替换原则,144-145
protected的数据,143
抽象的可覆盖(overridable)
子程序,145
抽象方面,89
单一派生类,146
覆盖了却无所事事的子程序,
146-147
可覆盖与不可覆盖的
(overridable vs.
non-overridable)子程序,
145-146
耦合(coupling),太紧,143
基准测试,结构化的(basis testing,
structured),503,505-509
即时绑定(just in time binding),253
极限编程(Extreme Programming)
定义,58
缺陷检测,471-472
协作,482
资源,708,856
集成(integration)
T-型集成,701
测试,499,697
策略,概述,694
持续集成,706
垂直分块法,696
存根,694,696
错误,定位,693
大爆炸,691
定义,689
方法小结,702
分块法,698
风险导向的集成,699
功能导向的集成,700-701
核对表,707
集成方式的重要性,689-691
监控,693
阶段式,691-692
接口规格,695,697
进度,694
客户关系,694
类,691,694,697
冒烟测试,703
每日构建(daily build)与冒
烟测试(smoke test),
702-706
破损的生成结果(build),703
三明治策略,698-699
未浮出水面的工作,702
要点,708
益处,690-691,693-649
增量,参见:增量集成
资源,707-708
自下而上策略,697-698
自上而下策略,694-696
自上而下策略的缺点,
695-696
集成开发环境(IDE),710-711
集合(collection),重构,572
集体所有权(collective ownership),
482;参见:协作
计划(planning)
建筑隐喻,18-19
类比论据,27-28
论述数据,28-30
逻辑论据,27
软件项目的良好实践表,
31-32
计数循环(counted loops);参见:
循环
计算机辅助软件工程(CASE)工具,
710
记录,重构,572
记录设计成果,117-118
纪律(discipline)的重要性,829
技术浪潮,确定你在其中的位置,
66-69
继承(inheritance)
case语句,147-148
Liskov替换原则,144-145
并行修改作为重构指标,566
定义,144
多重继承,148-149
覆盖的子程序没做任何操作,
146-147
过深的继承体系,147
函数,私用,覆盖,146
核对表,158
混合体,149
继承到访问权限,148
将共用项放在继承树中,146
将继承看作设计的一步,88
敬而远之,149
可覆盖与不可覆盖子程序的
比较,145-146
启发式设计,91-92
设计规则,144
涉及的决策,144
"是一个……"关系,144
私用,避免,143
私用数据与受保护数据之对
比,148
相似的派生类和基类,576
要点,160
与包含关系的比较,143
只有一个派生类,146
指导建议,清单,149
主要目标,136
加法的危险,295
加载时,绑定,253
架构(architecture)
安全性(security)设计,47
本地化(localization)规划,
48
变更,44,52
程序组织(program
organization),45-46
错误处理,49-50
定义,43
风险领域(risky area),明确,
53
复用的决策(reuse decisions),
52
概念完整性,52
构造块(building block)的定
义,45
国际化(internationalization)
规划,48
过度工程(overengineering),
51
核对表,54-55
互用性(interoperability),48
机器无关性(machine
independence),53
技术可行性(feasibility),51
开发相关资源,57
可伸缩性(scalability),48
类的设计,46
买(buying)组件还是造
(building)组件,51
前期准备,44
容错(fault tolerance),50
输入/输出(input/output),49
数据设计,46
所占百分比,按项目规模,
654-655
图形用户界面(GUI),47
性能导向(performance-
oriented),590
性能目标,48
延迟提交的策略(commitment
delay strategy),52
验证设计,50
要点,60
业务规则(business rules),46
用户界面设计,47
允许耗时,56
质量(quality),52-53,55
重要性,44
资源管理,47
减法,295
简单对象耦合,101
简单数据参数耦合,101
建模,隐喻.参见:隐喻,软件
建筑隐喻(building metaphor),16-19
健壮性
定义,197,464
索 引
代码大全(第2版)
928
架构的前期准备,51
用断言处理错误,193-194
正确性,权衡,197
将循环的判断外提,616-617
交叉引用工具(cross-reference
tools),713
脚本
编程工具,772
运行缓慢,600-601
脚手架
测试,523-524,531
调试,558
阶乘(factorials),397-398
阶段式集成,691-692
阶梯访问表,426-429
接口,类(interface, class)
不良抽象示例,134-135
不相关的信息,处理,137
布局,768
抽象层次不一致,示例,
135-136
抽象方面,89,133-138,566
创建的建议,135-138
从语义上破坏封装性,
141-142
调用类,重构,575
对象,设计,89
反操作,成对,137
混合体,149
集成,期间的接口规格说明,
695,697
接口中的公用子程序,141
可编程优于语义,137
扩展类,用以重构,576
良好抽象的示例,133-134
内聚性,138
评估抽象性,135
让阅读时更便利的原则,141
私用的实现细节,139-141
外部子程序,用其重构,576
委托与继承,重构,576
文档化,713,810
信息隐藏的任务,93
修改时破坏接口抽象性,138
严格描述类契约,106
要点,160
一致的抽象层次,135-136
移入子程序重构法,575
与接口抽象不一致的成员,
138
重构,575-576,579
子程序,未使用的,576
接口,子程序,参见:子程序的参数
公用的成员变量,576
外部子程序,用以重构,576
伪代码,226
移入子程序重构法,575
注释,808
子程序,隐藏,576
结对编程
编码规范,提供支持,483
步伐,跟上,483
定义,483
个人性格冲突,484
好处,484
何时不用结对编程,483
核对表,484
轮换结对人员的工作,483
旁观,483
显示器的可见性,484
新手结对,484
要点,497
与其它协作形式相比,
495-496
资源,496
组长,484
结构化编程
迭代,456
概述,454
顺序,454
选择,455
中心论点,456
结构化查询语言(SQL),65
结构化基础测试
理论,505-509
推荐,503
结构体
Visual Basic示例,320-322
定义,319
非结构化数据示例,320
过度使用,322
核对表,343
减少维护,323
交换数据,321-322
类当作结构体,319
明确数据关系,320
使用结构体调用子程序,322
使用结构体简化参数列表,
322
使用结构体简化数据操作,
320-322
数据关系,关系清晰的示例,
320
数据块,操作,320-322
要点,344
结构重组工具,715
解释型语言,性能,600-601
界面,图形,参见"图形化用户界面
(GUI)"
进度,估算.参见:估算进度
进攻式编程,206
经验,个人的,831-832
精简性设计目标,81
精确性(accuracy),464
警告标志,848-850
净室开发(cleanroom development),
521
就近原则,242,351
矩阵,参见:数组
具名常量,参见:常量
决策表(decision table),参见:表
驱动法
(K)
开发标准,IEEE,813
开发方法
不成熟的优化的问题,840
迭代式(iterative)方法;参
见:开发过程中的迭代
极限编程(Extreme
Programming),58,
471-472,482,708,856
敏捷开发(agile
development),58,658
团队过程(team processes),
839-840
序列式(sequential)方法,
35-36
质量控制(quality control),
840;参见:软件的质量
重要性,839-841
资源,58-59
自上向下(top-down)的方法,
111-113,694-696
自下而上(bottom-up)的方法,
112-113,697-698
开发过程(development processes),
参见:开发方法
开发者测试(developer testing),参
见:测试
开销(costs),参见:性能调整
变更的估计,666
调试,消耗的时间,474-475
估计,658,828
检测缺陷(defect),472
结对编程还是详查(pair
programming vs.
inspections),480-481
缺陷,519-520
软件质量的普遍规律(General
Principle of Software
Quality),474-475,522
协作的好处,480-481
修复缺陷,472-473,519
易错的(error-prone)子程序,
518
资源,658
科学的方法,经典步骤,540
索 引
代码大全(第2版)
929
可测试性(testability)
策略,467
定义,465
可读性(readability)
暴露出缺乏可读性的缺陷,
538
带来的维护好处,842
当作管理标准,664
定义,464
基于可读性而格式化,参见:
布局
基于可读性而命名变量,参
见:命名规则,变量命名
将可读性当作警告信号,849
结构,重要性,733-734
私用程序与公用程序的比较,
842
正面影响,841
重要性,13,841-843
专业开发,重要性,825
可覆盖的子程序,145-146,156
可见性(visibility);参考:变量的
作用域
类,93
耦合标准,100
可靠性(reliability)
定义,464
内聚性子程序,168
可扩展性(extensibility)的设计目标,
80
可理解性,465;参见:可读性
可伸缩性,48;参见:项目规模
可移植性(portability)
定义,464
数据类型,定义数据类型以便
移植,315-316
子程序,165
可用性(usability),463
可执行码工具(executable-code
tools)
build工具,716-717
安装(installation)工具,718
安装(setup)工具,718
编译器(compiler),参见:编
译器
代码库(code libraries),717
代码生成向导
(code-generation wizards),
718
链接器(linker),716
预处理器(preprocessor),
718-719
可重用性(reusability)
定义,464
架构的前期准备,52
空(null)对象,重构,573
空白
单条语句,753-754
定义,732
分组,737
空行,737,747-748
缩进,737
重要性,736
空行,用作格式化,747-748,765-766
控制结构(control structure)
case语句,参见:case语句
goto语句,参见:goto语句
if语句,参见:if语句
不常用的,概述,408
布尔表达式(boolean
expressions),参见:布尔表
达式
布局风格(layout style),
745-752
递归(recursive),参见:递归
迭代(iteration),255,456
返回,参见:return语句
复合语句(compound
statements),443
复杂度(complexity),456-459
核对表,459,773,780
后续行(continuation lines),
757
结构化编程(structured
programming),454-455
可靠性与复杂度
(complexity),457
空语句(null statements),
444-445
两次缩进begin-end对,
746-747
数据类型的关系,254-255
条件流程(conditional flow),
参见:条件语句
未缩进的begin-end对,746
文档(documentation),780
序列型数据(sequential data),
254
选择型数据(selective data),
254
循环(loop),参见:循环
要点,460
注解(commenting),804-805,
817
子程序多处返回,391-393
库,代码
目的,717
使用其中的功能,222
跨度,245,459
括号
布局,738
对称技巧,437-438
(L)
懒惰,830
浪潮的前期环境(early-wave
environments),67
老板就绪测试,对前期准备(boss
readiness test on prerequisites),
30-31
类(class)
case语句与继承,147-148
Liskov替换原则,144-145
PPP的替代,232-233
private成员,150
private数据与protected数据,
148
protected数据,148
public成员,139,141,576
Set()子程序,不必要的,576
包(package),155-157
包含(containment),143-144
编码子程序,从伪代码
(pseudocode),225-229
变更,153
并行修改(parallel
modifications),重构指标,
566
不相关的类,155
布局,768-771
参数传递,顺畅
(streamlining),153
测试先行开发(test-first
development),233
常量值,返回,574
成员变量(member variables),
命名,273,279
成员数目,143
抽象,核对表,157
抽象对象,建模,152
抽象数据类型(abstract data
type),参见:抽象数据类
型
初始化成员,243
创建的步骤,216-217
创建的理由,152-156
单体属性(singleton
property),确保,151
单向关联(unidirectional
association),577
单一实例(single-instance),
146
调用,重构,575
定义,125
对象,对比,86
对象名称,区别,272-273
对用户的假定(assumption),
141
方法(method),参见:子程
索 引
代码大全(第2版)
930
序
分解(factoring)的好处,154
封装(encapsulation),
139-143,158
复杂度(complexity)问题,
152-153
覆盖(overriding)子程序,
145-146,156
格式化(formatting),768-771
构造函数(constructor),
151-152
规定接口契约(contract),106
过程(procedure),参见:子
程序
过度格式化(overformatting),
770
函数(function),参见:函数,
子程序
核对表,157-158,774,780
混合体(mixins),149
基类(base),参见:基类
基类(superclasse),为共有代
码(common code),575
集成(integration),691,694,
697
集中控制,153
继承(inheritance),144-149,
158
架构的前期准备,46
间接调用其他类,150
建模真实世界的对象,152
禁止函数与操作符,150
警告标记(warning sign),
848,849
可复用性(reusability)的好
处,154
可见性(visibility),93
扩充(extension),重构,576
命名,277,278
内聚性(cohesion),作为重构
指标,566
耦合(coupling)方面的考虑,
100-102,142-143
派生类(subclass),165,575
派生类(descendant),重构的
指标,567
拼凑(hacking)法,233
评审(review)与测试(test)
的步骤,217
全局数据(global data),隐藏,
153
让阅读时更方便(read-time
convenience)的法则,141
设计,86,216,220-225,233
深继承树(deep inheritance
tree),147
实现(implementation)的核
对表,158
"是一个(is a)……"的关
系,144
双向联系(bidirectional
association),577
外部(foreign)子程序,重构,
576
万能(god)类,155
为程序族(program families)
做计划,154
伪代码(pseudocode),为设
计,232-234
委托还是继承(delegation vs.
inheritance),重构,576
文档,780,810
文件,771-772
无数据(data-free),155
限制合作(collaboration),150
相似的基类与派生类,576
信息隐藏(information
hiding),92-93
要点,160,234
一个文件多个类,布局,
769-770
隐藏实现细节,153
用存根对象(stub object)测
试,523
友元(friend class),涉及违反
封装(encapsulation
violation),141
语义上破坏封装(semantic
violations of
encapsulation),141-142
针对特定语言的问题,156
重构(refactoring),155,
574-576,578-579,582
资源,159
子程序,参见:子程序
子程序,未使用的,146-147,
576
子程序构建的步骤,217
子程序数目,150
最小化可访问性
(accessibility)原则,139
类,职责,合作者(CRC,
Class-Responsibility-Collaborator)
卡片,118
类的继承体系生成器
(class-hierarchy generators),713
类型创建
C++,312
Pascal示例,312-313
合法性校验的好处,314
核对表,318
集中化的好处,314
可靠性的好处,314
可移植性的好处,315-316
类,与类型作比,316
命名规则,315
目的,311-312
示例,313-315
所用语言,评价,314-315
信息隐藏,313-314
易于修改的好处,314
预定义类型,避免,315
原因,314
指导原则,315-316
重定义一个预定义的类型,
315
类型定义,278
链表
插入节点,327-329
删除指针,330
指针,隔离操作,325
链接器,716
了无章法的过程(sloppy process),
75-76
临时变量,267-268
临时的内聚性,169
灵活性(flexibility)
定义(defined),464
耦合标准化(coupling criteria
for),100-101
流,206
流程,开发,参见:开发方法
论述之规矩(discourse rules),733
逻辑表达式,参见:布尔表达式
布局,753
查询表,替代,614-615
代码调整,610-616
短路求值,610
惰性求值,615-616
恒等式,630
频率,以出现频率调整判断顺
序,612-613
消除冗余测试,610-611
性能比较,614
逻辑覆盖率测试,506
逻辑内聚性,170
(M)
买组件还是造组件(building vs.
buying components),18
蛮力调试(brute-force debugging),
548-549
冒烟测试,703
枚举类型(enumerated type)
C++,303-304,306
Java语言中,创建,307
Visual Basic语言,303-306
变更的好处,304
索 引
代码大全(第2版)
931
遍历,305
标准,306
布尔类型,替代,304
参数,303
创建,为Java,307
定义,303
好处,303
核对表,317
可读性(readability),303
可靠性(reliability)的好处,
304
可用的语言,303
明确赋值(explicit value)的
缺点,306
命名,269,274,277-279
首项无效(first entry invalid)
技巧,305-306
循环限制,305
验证,304-305
用全局变量模拟,338
用注释代替,802-803
每日构建(daily build)和冒烟测试
(smoke tests)
build小组,704
定义,702
好处,702
核对表,707
冒烟测试(smoke tests),703
破损的生成结果(broken
builds),703,705
未浮出水面的工作
(unsurfaced work),702
修订版本(revisions),704
压力(pressure),706
预先测试,要求(pretest,
requirement),704
暂存候补区(holding area for
additions),704-705
早上发布(morning releases),
705
诊断(diagnosis)的好处,702
重要性,706
自动化,704
美感(beauty),80
面向对象的编程(object-oriented
programming)
对象,参见:类,对象
多态,参见:多态
继承,参见:继承
相关资源,119,159
隐藏信息,参见:信息隐藏
敏捷开发(agile development),58,658
名称的缩写,283-285
名字的语音缩写,283
命名规则(naming convention)
a前缀的命名规则,272
C++,275-277
C语言,275,278
Java,276,277
Macintosh,275
"t_"前缀的命名规则,272
Visual Basic,278-279
保留名,287
变量命名,参见"变量名"
标准前缀,279-281
参数,178
长度,不限制,171
常量,273-274
常用操作,172-173
辞典,使用,283
大小写,274,286
大小写不敏感的语言,273
短变量名,282-285,288-289
对仗,使用,172
多种自然语言,287
发音指导原则,283
非正式,272-279
分隔符,274
关系,强调,271
过程描述,172
函数返回值,172
好处,270-271
何时采用,271
核对表,288-289,780
混合语言的注意事项,276
减少命名增生的好处,270
仅通过数字区分,171
可读性,274
跨项目方面的好处,270
类成员变量,273
类名与对象名,272-273
令人误解的名字,285
枚举类型,269,274,277-279
描述性的指导原则,171
名字包含的信息种类,277
名字的相似处,过多,285
命名含义,太相似,285
目的,270-271
拼错单词,286
全局变量,273,342
输入参数,274
数据类型与变量名,272-273
数字,286
数组,280-281
缩写的指导原则,282
缩写名称,282-285
同音异义字,286
文档说明,284-285,778-780
文件,811
匈牙利命名法,279
要点,289
用户自定义类型(UDT)缩写,
279-280
与语言无关的指导原则,
272-274
语义前缀,280-281
语音缩写,283
正式程度,271
子程序,171-173,222
字符,易混淆,287
模板方法模式,104
模板工具,713
模仿的纯块布局风格(emulated pure
blocks layout style),740-743
模块,耦合的注意事项,100-102
模块化
全局变量,对模块化的害处,
337-338
设计目标,107
模式(pattern)
表格,104
工厂方法(Factory Method),
103-104
减少出错的好处,103
减少复杂度,103
建议的替代模式,103
交流方面的好处,104
缺点,105
相关资源,120
益处,103-104
牡蛎养殖隐喻,15-16
目标,软件质量,466,468-469
目录
表,xxxi-xxxii
核对表,xxix-xxx
图,xxxiii-xxxvii
(N)
内存(memory)
初始化工作内存,244
分配,错误检测,206
分页操作对内存性能的影响,
599
工具,527
破坏,指针造成,325
填充工具,244
指针,造成的内存破坏,325
内聚(cohesion)
接口,类,138
强度削减(strength
reduction),623-624,
630-632
巧合的内聚性(coincidental
cohesion),170
子程序,设计,168-171
内联子程序(inline routine),184-185
索 引
代码大全(第2版)
932
能够随时扔掉的代码,114
能力成熟度模型(CMM,Capability
Maturity Model),491
(O)
偶然(次要)的问题(accidental
problems),77-78
耦合(coupling)
大小,100
对象参数类型(object-
parameter type),101
基类与派生类之间的,143
简单对象类型,101
简单数据参数类型
(simple-data-parameter
type),101
可见性(visibility),100
类,太紧,142-143
灵活性(flexibility),100-101
目标,100
设计方面的考虑,100-102
松散(loose),80,100-102
语义类型(semantic type),102
(P)
排序,递归算法,393-394
"抛弃一个"之隐喻,13-14
培植系统,隐喻(growing a system
metaphor),14-15
配置管理(configuration
management)
SCM(Software Configuration
Management),665
版本控制(version-control)软
件,668
备份计划,669,670
变更控制委员会(change-
control boards),667
标明变更区域,97-99
成本,估计,666
成组处理变更请求,666
大量变更,666
代码改动,667-668
定义,664
估计变更成本,666
官僚主义(bureaucratic)方面
的考虑,667
核对表,669-670
机器配置(machine
configurations),重现
(reproducing),668
架构预料变更(architectural
anticipation of change),52
目的,664-665
设计变更,666-667
需求变更,41,664,666-667
资源(resources on),670
拼凑式设计(hacking approach to
design),233
(Q)
启发式方法(heuristics)
错误猜测,513
设计,参见:启发式设计
与算法(algorithm)比较,12
启发式设计(heuristic design)
绑定时间(binding time)方 面
的考虑,107
避免失败,106-107
变更,标明区域,97-99
测试,预料,106
抽象,形成一致的,89-90
迭代实践(iteration practice),
111-117
对象,真实世界,寻找,87-89
非确定性(nondeterministic),
87
分层结构(hierarchies),
105-106
分而治之(divide and conquer)
技术,111
封装(encapsulation),90-91
规则总结,108
核对表,122-123
画图,107
记录工作,117-118
继承(inheritance),91-92
建议多种方法,110
接口,用契约(contracts)严
格描述,106
蛮力(brute force),107
面向对象(object-oriented)相
关的资源,119
模块化(modularity),107
模式(pattern),103-105,120
模式的替代方案,103
模式在沟通方面的好处,104
目标,核对表,122-123
耦合方面的考虑,100-102
强内聚(strong cohesion),105
设计过程的本质,76
实践,110-118,122
完备度(completion),确定,
115-117
详细程度(level of detail),所
需的,115-117
协作(collaboration),115
信息隐藏(information
hiding),92-97,120
严格描述类的契约(class
contracts),106
要点,123
用模式减少错误,103
原型(prototyping),114-115
责任(responsibilities),赋予
对象,106
正式程度(formality),确定,
115-117
指导建议,109-110
中心控制点,107
资源,121
自下而上设计法,112-113
自上而下设计法,111-112,
113
谦卑(humility)在性格中的角色,
821,826,834
前期准备,前期
WIMP综合症(为什么Mary
不在编程 !),26
WISCA综合症(为什么Sam
不在写代码 !),26
不周全的准备,诱因,25-27
成功需要的技能,25
错误检测,及早进行,29-30
迭代式开发法,28,33-34
"管理者无知"的问题,26
"过早编码"之错误,25
核对表,59
混合使用序列式开发法和迭
代式开发法,34-35
架构,参见:架构
老板就绪测试,30-31
类比论据,27-28
逻辑论据,27
目标,25
目标是降低风险,25
软件项目的良好实践表,
31-32
数据论述,28-30
问题定义,36-38
项目种类,31-33
需求开发,参见:需求
要点,59-60
有力论据,27-31
允许的时间,55-56
在序列式开发法和迭代式开
发法之间做出选择,35-36
重要性,24
前期准备,参见:前期准备,前期
前条件
验证,192-193
子程序设计,221
前缀,标准化,279-281
嵌入式,性命攸关的系统(embedded
life-critical systems),31-32
嵌套的if语句
过多的嵌套层次,445-454
将其按功能分解(functional
索 引
代码大全(第2版)
933
decomposition),450-451
提取到子程序中,449-451
用break语句块简化之,
446-447
用于减少嵌套的技术的总结,
453-454
重新测试条件(retesting
conditions)使之简化,
445-446
重新设计,453
转换为case语句,448-449,
451
转换为if-then-else语句,
447-448
转换为采用工厂方法(Factory
Method)模式的方法,
452-453
转换为采用面向对象
(object-oriented)的方法,
452-453
嵌套循环
出于性能考虑的循环次序,
623
设计,382-383,385
强度,参见:内聚性
强制类型转换,避免,334
桥接(Bridge)模式,104
全局变量(global variables)
"g_"前缀原则,340
别名问题(aliasing problems),
336-337
持久性(persistence),251
初始化(initialization)问题,
337
大型对象,343
代码复用(code reuse)问题,
337
代码重入(re-entrant code)问
题,337
访问器子程序,参见:访问器
子程序
改变,无意中的,336
概述,335-336
核对表,343-344
降低风险的策略,342-343
局部变量优先的指导建议,
339
具名常量,模拟,338
类变量,替代方案,339
流浪数据,消除,338
命名,263,273,277,278,
279,342
模块化(modularity),破坏,
337-338
模拟枚举类型,338
锁定(locking),341
替代方案,339-342
信息隐藏问题,95-96
要点,344
用以保存值,338
语义耦合(semantic
coupling),102
在类中隐藏实现,153
中间结果,避免,343
重构(refactoring),568
注释(annotating),343
注释(commenting),803,809
子程序用作参数,336
缺陷,代码中的(defects in code)
《代码大全》示例,490-491
百分比,测量,469-472
查找,核对表,559-560
程序员失误(programmers at
fault),519
错误核对表,489
范围,519
分布(distribution),517-518
分类(classification),518-520
根源,表格,518
构建,比例,520-521
构建领域之外,519
间断(intermittent),542-543
检测的成本,472
可读性改善(readability
improvements),538
拼写错误(clerical errors
(typos)),519
期望率(expected rate),
521-522
容易修正的缺陷,519
数据库(database),527
通过各种技术检测,表格,470
稳定(stabilizing),542-543
误解设计,根源,519
项目规模的影响,651-653
性能问题,601
修复,参见:调试,修复缺陷
修复的成本,472-473
易错的类,517-518
益处,537-538
正式检查(formal
inspections),检测缺陷,参
见:详查(formal
inspections)
重构,在修复之后,582
自己从中学到知识,538
(R)
绕弯解决(workaround),说明
(commenting),800
人的方面(human aspects),软件中
个人的
开发,参见:性格
日志
测试工具,526
防御式编程指南,210
容错(fault tolerance),50
容器类(container classes),310
软件参考书目(bibliographies,
software),858
软件的首要技术使命(Software's
Primary Technical Imperative),92
软件的质量(software quality)
标准,IEEE,477,814
测试,465,467,500-502
程序员的工作表现,基于的目
标,468-469
调试,所扮演的角色,
474-475,536
对变更进行控制的过程,468
发展质量保证活动,467-468
复查,467
核对表,476
极限编程,471-472
建议联合使用多种技术,473
建议综合各种缺陷检测技术,
470-471
健壮性,464
结果的量化,468
精确性,464
可读性,464
可靠性,464
可理解性,465
可维护性,464
可移植性,464
可用性,463
可重用性,464
灵活性,464
门,467
明确定义质量保证工作,466
目标,设置,466,468-469
内在特性,464-465
缺陷度量百分比,469-472
缺陷检测的若干技术,表格,
470
软件工程指南,467
软件质量的普遍原理,
474-475
什么时候进行质量保证工作,
473
适应性,464
特性之间的联系,465-466
外部审查,467
外在特性,463-464
完整性,464
相关资源,476
效率,464
协作构建,参见:协作
修正缺陷的成本,472-473
索 引
代码大全(第2版)
934
要点,477
优化竞争关系,465-466
原型制作,468
找出缺陷的成本,472
正确性,463
软件工程的资源综述,858
软件工程指南,467
软件构建概述
编程就是构建,5
编程与构建的比较,4
定义,3-6
非构建活动,6
构建活动,清单,3
"确保完成"之本性,7
任务,清单,5
软件开发的核心活动,7
软件开发总时间的比例,7
生产率,重要性,7
要点,8
源代码对软件的描述,7
源代码即为软件描述,7
重要性,6-7
主要活动,4
软件开发文件夹(SDF, Software
Development Folder),778
软件开发者的阅读计划,860-862
软件开发资料库
参考书目,858
概述,855,857-858
构建,856
软件工程综述,858
阅读计划,860-862
杂志,859-860
软件设计,参见:设计
软件生长隐喻,15-16
软件先知,851
软件项目类型,31-33
软件演化
背景,563-564
构建与维护,564
基本准则,565
哲学,564-565
质量提高与降低,564
软件演化的基本准则(Cardinal Rule
of Software Evolution),565
软件隐喻,参见:隐喻,软件
软件质量,参见:软件的质量
软件质量的普遍原理(General
Principle of Software Quality)
成本,522
调试,537
定义,474-475
协作效果,481
(S)
三明治集成(sandwich integration),
698-699
三思而后行,23
扇出(fan-out),81
扇入(fan-in),80
舍入误差,297
设计(design)
BDUF(Big Design Up Front),
119
IEEE标准,122
UML图,118
包的层次,82-85
本质问题(essential
problems),77-78
变更,标明区域,97-99
变更的管理,666-667
标准,IEEE,122
标准技术目标,81
测试实现,503
层次(hierarchies),105-106
层次(levels),82-87
层次性目标(stratification
goal),81
抽象,形成一致的,89-90
低,中扇出的目标
(low-to-medium fan-out
goal),81
迭代实践,111-117
定义,74
对象,真实世界,找出,87-89
非确定性的本质
(nondeterministic nature),
76,87
分而治之(divide and conquer)
技术,111
封装(encapsulation),90-91
高扇入目标(high fan-in
goal),80
高质量的特性,80-81
工具,710
构建活动,73-74
管理复杂度,77-80
核对表,122-123,781
绘制图表,107
记录工作,117-118
继承(inheritance),91-92
精简性目标(leanness goal),
81
可复用性目标(reusability
goal),80
可扩展性目标(extensibility
goal),80
可视化文档(visual
documentation),118
可移植性目标(portability
goal),81
类,分解为,86
了无章法的过程(sloppy
process),75-76
量度(metrics),警告信号,
848
美感(beauty),80
面向对象(object-oriented)的
资源,119
模式,常用,参见:模式
目标核对表,122-123
偶然(次要)的问题(accidental
problems),77-78
耦合(coupling)方面的考虑,
100-102
启发式(heuristic),参见:启
发式设计
契约式(contract),233
强内聚(strong cohesion),105
权衡(tradeoff),76
软件系统层次,82
实践,110-118,122
实践启发式方法,参见:启发
式设计
受限,76
数据库访问子系统,85
松耦合目标(loose coupling
goal),80
讨论,总结,117
完备度,确定,115-117
维护性目标(maintenance
goals),80
维基(wiki),记录,117
文档,当作,781
文档,过度,117
系统依赖子系统,85
险恶的问题(wicked
problem),本质,74-75
详细程度,115-117
协作(collaboration),115
信息隐藏(information
hiding),92-97,120
性能调整方面的考虑,
589-590
严格描述类的契约(class
contracts),106
要点,123
业务逻辑子系统,85
用户界面子系统,85
优良实践表,31-32
优先级的确定(prioritizing),
76
原型(prototyping),114-115
正式程度(formality),确定,
115-117
智力限制(mental
limitations),人类,79
中央控制点,107
索 引
代码大全(第2版)
935
资源,119-121
子程序,86-87
子系统层次,82-85
子系统之间的通信,83-84
自上而下的方法,111-113
自然形成(emergent nature),
76
自下而上设计法,112-113
足够,确定,118-119
设计的层次
包,82-85
对系统有依赖性的子系统,85
概述,82
类,分解为,86
软件系统,82
数据库访问子系统,85
业务逻辑子系统,85
用户界面子系统,85
子程序,86-87
子系统,82-85
设计的受限制特性,76
设计过程的不确定性,76,87
设想陈述的先决条件,参见:问题定
义的先决条件
设置代码,重构,568-569
深入语言去编程,68-69,843
神秘变量,避免,292,297-298,
308-309
生产率
良好构建活动的作用,7
项目规模,影响,653
业界平均值,474
生命周期模型
开发标准,813
优良实践表,31-32
声明(declaration)
const,建议,243
final,建议,243
放置,762
格式化(formatting),761-763
靠近第一次使用的地方定义
的原则,242-243
命名,参见:命名约定
使用全部已声明的变量,257
数值数据,注释,802
顺序,762
一行多个,761-762
隐式声明(implicit
declaration),239-240
指针(pointer),325-326,763
注释(commenting),794,
802-803,816
实例化对象
抽象数据类型(ADT),132
单件(singleton),104,151
工厂方法(Factory Method)
模式,103-104
"使代码易于自上而下地阅读"的指
导建议,351-352
性命攸关的系统,31-32
使用结构体交换数据,321-322
事件处理器(event handlers),170
试验,作为学习方法(experimentation
as learning),822-823,852-853
试验性原型(experimental
prototyping),114-115
适配器(Adapter)模式,104
适应性(adaptability),464
释放(deallocation)
goto语句,399
指针(pointer),of,326,330,
332
释放对象(disposing of object),206
收尾步骤(cleanup step),伪代码编
程过程,232
收尾代码,重构,568-569
受保护数据,148
书本范例(book paradigm),812-813
输入/输出(I/O)
架构的先决条件,49
识别容易变化的区域,98
性能考虑,598-599
输入/输出,参见:I/O(输入/输出)
输入参数,274
数据(data)
变更,确定区域,99
测试,生成器,524-525
代码调整,参见:数据变换,
为代码调整
好数据,测试,515-516
坏数据,测试,514-515
架构的前期准备,46
旧数据,兼容性,516
类型(type),参见:数据类
型
设计,46
已定义的状态(defined state),
509-510
已定义-已使用路径
(defined-used path),测试,
510-512
已进入的状态(entered state),
509
已使用的状态(used state),
509-510
已推出的状态(exited state),
509
已销毁的状态(killed state),
509-510
正常情况的错误(nominal
case errors),515
组合状态(combined states),
509-510
数据变换(data transformation),为
代码调整
浮点转为整形,625
缓存数据,628-629
目的,624
让数组维度最小,625-626
让数组引用最少,626-627
索引数据,627-628
数据级重构,571-572,577
数据记录工具,526
数据结构(data structure),参见:结
构
数据库(database)
SQL语言,65
性能问题,601
子系统设计,85
数据类型(data type)
"a"前缀,272
"t_"前缀,272
变更,标明区域,99
变量,区分,272-273
布尔(boolean),参见:布尔
变量
抽象数据类型(abstract data
type),参见:抽象数据类
型(ADT)
创建,参见:类型创建
迭代型数据(iterative data),
255
定义,278
二进制编码的十进制数
(BCD),297
浮点(floating-point),参见:
浮点数据类型
复杂(complex),参见:结构
过多使用的基本数据类型
(primitives),567
核对表,316-318
货币数据类型(Currency),
297
结构,参见:结构
枚举类型(enumerated type),
参见:枚举类型
命名,273,277,278
数值,参见:数值数据类型
数组(array),参见:数组
序列型数据(sequential data),
254
选择型数据(selective data),
254
要点,318
用户定义的(user-defined),
参见:类型创建
与控制结构的关系,254-255
索 引
代码大全(第2版)
936
整型(integer),参见:整数
数据类型
指针(pointer),参见:指针
重构为类,567,572
资源,239
字符,参见:字符数据类型
字符串,参见:字符串数据类
型
数据流测试(data flow testing),
509-512
数据认知测试(data literacy test),
238-239
数据字典(data dictionaries),715
数值,文字量,292
数值数据类型
0,除以0,292
BCD(二进制编码的十进制),
297
比较,440-442
编译器警告,293
操作开销,602
浮点类型,295-297,316,602
核对表,316
混合类型的比较,293
神秘数值,避免,292
声明,注释,802
数量级,相差巨大,运算,295
数值文字量,避免,292
溢出,293-295
硬编码的0和1,292
整数,293-295
整数取值范围,294
转换,展示,293
数组(array)
C语言中的宏,311
foreach循环,372
操作代价,602
串话(cross-talk),311
定义,310
端点(end points),检查,310
多维(multidimensional),310
核对表,317
命名约定,280-281
容器作为替补,310
哨兵值(sentinel),循环检测,
621-623
顺序访问的指导建议,310
维数(dimension),最小化,
625-626
下标(index),310-311
性能调整,593-594,603-604
循环,387-388
引用(reference),最小化,
626-627
引用的布局(layout of
references),754
语义前缀(semantic prefixes),
280-281
重构(refactor),572
顺序上的内聚性,168
私用数据,148
松散耦合
策略,100-102
作为设计目标,80
算法(algorithm)
隐喻(metaphor),11-12
与启发式方法/试探法
(heuristics)的比较,12
注释,809
资源,607
子程序,223
算术表达式(arithmetic expression)
乘法,改为加法,623-624
舍入误差(rounding errors),
297
数量级相差巨大的数之间的
加减运算,295
误导的优先级(precedence)
示例,733
随机数据生成器,525
缩进,737,764-768
索引,辅助以数据类型,627-628
索引访问表,425-426,428-429
锁定全局数据,341
(T)
调试(debugging)
diff工具,556
lint工具,557
编译器,作为调试工具,549,
557
变更,最近的,547
表现上的差异,536-537
猜测,539
测试,比较,500
测试用例创建,544
查找缺陷(defects),540,
559-560
忏悔式调试(confessional
debugging),547-548
常见的缺陷清单,547
成本(cost),29-30,474-475
程序员经验的影响,537
重新检查易错代码
(defect-prone code),547
单元测试,545
低效方法,539-540
定位错误源,543-544
定义,535
断点(breakpoint),558
多条编译信息,550
二分查找(binary search),代
码,546
防御式(defensive),参见:
调试助手
符号调试器(symbolic
debuggers),526-527
各种测试用例,545
工具,526-527,545,556-559,
719;参见:调试助手
行数,549
核对表,559-561
假想测试(hypothesis
testing),543-544,546
脚手架(scaffolding),558
警告,视为错误,557
科学方法,540-544
可读性的改进,538
扩大嫌疑范围,547
理解问题,539
历史,535-536
列出可能性,546
逻辑检查工具,557
蛮力(brute-force),548-549
盲目的根源,554-555
迷信的方法,539-540
"魔鬼的助手"(Satan's
helpers),539-540
缺陷当作机遇,537-538
软件质量中的角色,536
时间,设置上限,549
缩小代码搜索范围,546
调试工具,526-527,545,
556-559,719;参见:调试
助手
推荐的方法,541
唾手可得的修复,539
稳定错误(stabilizing errors),
542-543
系统调试器,558
项目范围的编译器设置,557
心理方面(psychological)的
考虑,554-556
休息一下,548
修复缺陷,550-554
要点,562
引号,误置的,550
语法检查,549-550,557,560
源代码比较器(source-code
comparator),556
增量的方法,547
执行剖测器(execution
profiler),557-558
助手,参见:调试助手
注释,误置的,550
资源,561
自己从中学到知识,538
索 引
代码大全(第2版)
937
调试助手(debugging aids)
C++的预处理器
(preprocessors),207-208
case语句,206
版本控制(version control)工
具,207
产品约束,开发版本,205
存根(stub),208-209
攻击式编程(offensive
programming),206
计划移除,206-209
尽早引入,建议,206
目的,205
预处理器(preprocessor),
207-208
指针,检查,208-209
条件语句(conditional statement)
case语句,参见:case语句
else子句,358-360
if-then-else语句串(chain),
358-360
if语句,参见:if语句
switch语句,参见:case语句
按频率顺序进行判断,
612-613
布尔变量(boolean variable),
推荐,301-302
调用布尔函数(boolean
function),359
查询表(lookup table),替代,
614-615
常见情况置先(common cases
first)原则,359-360
错误处理示例,356-357
定义,355
短路求值(short-circuit
evaluation),610
覆盖所有情况,360
核对表,365
空if子句,357
普通if-then语句,355-357
相等(equality),分支,355
消除测试冗余(testing
redundancy),610-611
性能比较,614
循环,条件(conditional),参
见:循环
要点,366
正常路径置先(normal path
first)建议,355
正常情况置先(normal case
first)建议,356-357
重构(refactoring),573
通信上的内聚性(communicational
cohesion),169
图表(diagram)
UML(Unified Modeling
Language),118
启发式设计(heuristic
design),使用,107
图目录,xxxiii
图形化设计工具,710
图形用户界面(GUI)
架构(architecture)的前期准
备(prerequisites),47
重构(refactor)其中的数据,
576
子系统(subsystem)设计,
85
团队(team),参见:管理构建
build小组,704
分配时间,681
风格问题,683-684
管理者,686
过程,重要性,839-840
核对表,69
扩充团队以便赶上进度,676
私密的办公室,684
所用的开发过程,840
物理环境,684-685
相关资源,685-686
项目规模,影响,650-653
信仰问题,683-684
性能差异,681-683
团队软件开发过程(TSP,Te a m
Software Process),521
退出循环,369-372,377-381
(W)
外部审查(external audit),467
外部文档(external documentation),
777-778
外观(Facade)模式,104
完整性,464
万能类(god class),155
维护(maintenance)
可读性(readability)的好处,
842
可维护性(maintainability)的
定义,464
容易出错的子程序,排优先级
(prioritizing),518
设计目标,80
修复缺陷(defects),源于维
护的问题,553
用结构体(structure)来减少
维护,323
注释(comment)所需的维护,
788-791
伪代码(pseudocode)
PPP(伪代码编程过程),参
见:伪代码编程过程
PPP(伪代码编程过程),核
对表,233-234
变更,效率,220
不好的示例,218-219
测试,计划,222
创建伪代码的要点,234
从代码库中寻求功能,222
从伪代码进行编码,225-229
从伪代码进行高层次的注释,
226-227
从伪代码进行声明,226
从伪代码进行注释,220,791
错误处理的注意事项,222
迭代精化(iterative
refinement),219,225
定义,218
好处,219-220
好的示例,219
检查错误,230-231
类,创建步骤,216-217
命名子程序,222
审阅,224-225
算法,研究,223
问题定义,221
先决条件(prerequisite),221
性能的注意事项,222-223
循环设计,385-387
有效使用伪代码的指导建议,218
在注释下面填充代码,
227-229
重构(refactoring),229
子程序(routine),创建步骤,
217,223-224
子程序设计,220-225
子程序示例,224
子程序数据结构,224
子程序头部注释(header
comment),223
伪代码编程过程(PPP,Pseudocode
Programming Process)
编写伪代码的步骤,223-224
测试代码,222, 231
程序库中已有的功能,222
从伪代码编写子程序,
225-229
错误处理的注意事项,222
迭代(iteration),225
定义,218
高层次(high-level)注释,
226-227
核对表,233-234
检查错误,230-231
设计子程序,220-225
审查(review)伪代码,224-225
收尾工作(cleanup steps),232
算法(algorithm)研究,223
索 引
代码大全(第2版)
938
替代方案,232-233
问题定义(problem
definition),221
先决条件(prerequisites),221
消除错误,231
性能方面的考虑事项,
222-223
要点,234
源于伪代码的声明
(declarations),226
在注释(comment)下面填充
代
码,227-229
重复步骤,232
重构(refactoring),229
逐行执行(stepping through)
代码,231
子程序的数据结构(data
structure),224
子程序命名,222
子程序示例,224
子程序头部注释,223
文档(documentation)
CRC(class-responsibility-colla
borator) 卡片,118
Javadoc,807,815
标准,IEEE,813-814
参数假定(parameter
assumptions),178
抽象数据类型(abstract data
type),128
单元开发文件夹(UDF,Unit
Development Folder),778
风格差异(style difference),
管理,683
核对表,780-781,816-817
坏代码,568
记录工作,117-118
可视化,设计,118
控制结构(control structure),
780
类(class),780
名称,284-285,778-779,780
名称的缩写,284-285
软件开发文件夹(SDF,
Software Development
Folder),778
设计作为文档,117,781
书本范例(Book Paradigm),
812-813
数据的组织,780
外部(external),777-778
为何与如何(why vs. how),
797-798
伪代码(pseudocode),得自,
220
详细的设计文档(detailed-
design documents),778
项目规模的影响,657
要点,817
依赖性(dependency),明确,
350
源代码作为文档,7
注释(comments),参见:注
释
资源,815
子程序(routine),780
子程序参数假定(parameter
assumptions),178
自说明的代码(self-
documenting code),778-781
文件(files)
C++源文件顺序,773
布局(layout),771-773
抽象数据类型(ADT),视为,
130
改动记录(authorship
records),811
命名,772,811
删除多个,示例,401-402
文档,810-811
子程序(routine),772
稳定错误(stabilizing errors),
542-543
问题定义的先决条件,36-38
问题域(problem domain),基于问
题域编程,845-847
无限循环(endless loop),367,374
无效输入,参见:合法性校验
(X)
析构函数(destructor),异常,199
习惯(habit),程序员的,833-834
系统测试,500
系统调用(system call)
代码调整,633-634
性能问题,599-600
系统干扰器(perturber),527
系统级重构,576-577,579
系统架构,参见:架构
系统生长(accreting a system)的隐
喻,15-16
下标(index),循环
变量名,265
核对表,389
枚举类型,305
替代方案,377
最终取值,377-378
作用域,383-384
先知(oracle),软件,851
险恶的问题(wicked problem),74-75
线程(thread),337
相等(equality),浮点数,295-296
详查(formal inspections)
《代码大全》示例,490-491
CMM(能力成熟度模型),491
报告,488-489
表现评估(performance
appraisals),487
场景方法(scenarios
approach),488
错误核对表,489
代码评审(code review)的速
度,488
定义,485
返工阶段(rework stage),489
概述阶段(overview stage),
487
跟进阶段(follow-up stage),
489
过程,487-489
核对表,491-492
计划阶段(planning stage),
487
记录员角色(scribe role),486
角色(roles),486-487
阶段(stages),487-489
经理角色(management role),
486-487
评审员角色(reviewer role),
486
评审(review),比较,485
期望的结果,485-486
三小时解决方案会议
(three-hour solutions
meeting),489
细调(fine-tuning),489
详查会议(inspection
meeting),488
要点,497
益处总结,491
与其他协作方法的比较,
495-496
责备游戏(blame game),490
主持人角色(moderator role),
486
准备阶段(preparation stage),
487-488
资源,496-497
自尊心(ego),490
作者角色(author role),486
详查(inspection),参见:正式检查
(formal inspection)
详查中的记录员(scribe)角色,486
详查中的评论员(reviewer)角色,486
详查中的主持人(moderator)角色,
486
详查中的作者(author)角色,486
索 引
代码大全(第2版)
939
详细设计文档(detailed-design
documents),778
项目规模
单一产品,一个用户,656
单一产品,多个用户,656
范围,651
方法论的注意事项,657-658
复杂度(complexity),影响,
656-657
概述,649
估算误差,656-657
活动,快速增长的活动清单,
655
活动类型,影响,654-655
建筑隐喻,19
人与人交流,650
生产率,影响,653
文档(documentation)要求,
657
系统,656
系统产品,656
相关资源,658-659
要点,659
引发的错误,影响,651-653
正规性(formality)要求,657
项目种类,相应的前期准备,31-33
效率(efficiency),464
协作(collaboration)
标准,IEEE,497
测试,比较,481
成本优势,480-481
传承(mentoring)方面,482
代码阅读,494
定义,479,480
公开演示(dog-and-pony
shows),495
构建之后继续保持协作,483
极限编程法(Extreme
Programming method),482
集体所有权(collective
ownership)的好处,482
技术对比表,495-496
结对编程(pair
programming),参见:结对
编程
开发时间(development time)
的好处,480
目的,480
软件质量的普遍原理(General
Principle of Software
Quality),481
设计阶段(design phase),115
详查(inspections),参见:正
式检查(informal
inspection)
要点,497
正式检查(formal
inspections),参见:正式检
查
走查(walk-throughs),492-493
心理距离,556
心理取向,554-555
心理因素,参见:性格,个人
信息隐藏(information hiding)
抽象数据类型(ADT),127
创建类型,313-314
访问器(accessor)子程序,
340
隔栏,95-96
过度分散的问题,95
接口,类,93
类的隐私权,92-93
类的内部数据误为全局数据,
95-96
类设计的注意事项,93
类的实现细节,153
例子,93-94
秘密的概念,92
秘密的种类,94
性能问题,96
循环依赖的问题,95
重要性,92
资源,120
性能调整(performance tuning)
DES(数据加密标准)示例,
605-606
编码的用户角度,588
编译器的注意事项,590,
596-597
不成熟的优化,840
操作,常见操作的开销,
601-603
操作系统的注意事项,590
从程序需求角度看,589
从设计角度看,589-590
代码调整,参见:代码调整
代码缺陷,601
代码行,减少代码行数,
593-594
代码质量,影响,588
低效的元凶,598-601
方法总结,606
分页操作(paging operation),
599
概述,643-644
何时调整,596
核对表,607-608
计时问题,604
架构的前期准备,48
解释型(interpreted)语言与
编译型(compiled)语言的
比较,600-601
目的,587
内存操作与文件操作的比较,
598-599
权衡程序目标,595,605
输入/输出,598-599
数据库索引,601
数组,593-594,603-604
速度,重要性,595-596
算法选择,590
无稽之谈,593-596
系统调用,599-600
相关资源,606-607
信息隐藏的注意事项,96
性能测量,603-604
要点,608
硬件的注意事项,591
正确性,重要性,595-596
注释,影响,791
专为功能进行性能调整,595
资源占用目标,590
子程序设计,165,222-223,
590
匈牙利命名法(Hungarian naming
convention),279
修复缺陷(defect)
保存未修复的代码(unfixed
code),552
变更的理由,553
初始化缺陷(initialization
defects),553
匆忙,影响,551
单元测试(unit test),554
核对表,560
检查修复情况,553
先要理解问题(understand
first)的建议,550-551
特殊情况(special cases),553
维护事宜,553
相似缺陷,查找,554
一次一改的原则(one change
at a time rule),553
诊断确认(diagnosis
confirmation),551
症状,修复问题根源,552-553
需求(requirement)
变更控制(change-control)过
程,40-41
变化率,典型值,563
不报告就写代码,26
测试,503
定义,38
放弃(dump)项目,41
非功能需求,核对表,42
功能需求,核对表,42
好处,38-39
索 引
代码大全(第2版)
940
核对表,40,42-43
交流变更,40-41
开发方法,41
开发过程对需求的作用,40
良好实践表,31-32
配置管理(configuration
management),664,666-667
商业案例,41
完备性,核对表,43
稳定需求,39-40,840
性能调整,589
需求错误,影响,38-39
需求的质量,核对表,42-43
需求开发的相关资源,56-57
要点,60
允许的时间,55-56
重要性,38-39
需求的完备性,核对表,43
序列,代码,参见:用子程序隐藏块,
165
结构化编程的概念,454
顺序,参见:依赖关系,代码
顺序
序列式开发法,33-36
选择,代码,455
选择性(selective)数据,254
循环(loop)
break语句,371-372,379-380,
381
continue语句,379,380,381
do循环,369-370
foreach循环,367,372
for循环,372,374-378,
732-733,746-747
off-by-one(差1)错误,
381-382
repeat-until子句,377
while循环,368-369
安全计数器,378-379
变量初始化,249
变量的指导原则,382-384
变量核对表,389
变量命名,382-383
长度,385
长度削减,623-624
初始化代码,373,374
串话(cross talk),383
代码调整,616-624
带goto的循环,371
带标号的break语句,381
迭代器循环,367,456
迭代型数据结构,255
定义,367
端点的注意事项,381-382
多条break语句,380
非正常循环,371
改动循环下标,377
合并,617-618
核对表,388-389
后续行,757
计数循环,367;参见:for循
环
建议的括号,375
尽可能减少循环内部的工作,
620-621
进入循环的指导建议,
373-375,388
空循环,避免,375-376
空语句,重写,445
连续求值的循环,367;参见:
while循环
枚举类型,305
内务语句,376
嵌套,382-383,385,623
嵌套的放置次序,623
切换(switch),616
确认终止条件,377
融合,617-618
冗余判断,消除,610-611
哨兵值(sentinel)判断,
621-623
设计,过程,385-387
数组与循环的关系,387-388
特定语言,循环种类表,368
退出循环的指导原则,
369-372,377-381,389
外提判断,616-617
伪代码方法,385-387
问题,概述,373
无限循环,367,374
下标(index)的变量名,265
下标(index)的最终取值,
377-378
下标(index)的作用域,
383-384
性能的注意事项,599
循环规模作为重构指示,565
循环结束条件检查,位置,368
循环内的指针,620
循环体,处理,375-376,388
循环下标的核对表,389
要点,389
"一个循环只做一件事"的指
导建议,376
展开,618-620
终止条件,使之明显,377
种类,推广,367-368
重构,565,573
注释,804-805
子程序,385
组合判断,简化,621-623
循环的哨兵值(sentinel)判断,
621-623
循环依赖(circular dependencies),
95
循环展开,618-620
循环中的安全计数器,378-379
(Y)
延迟提交策略(commitment delay
strategy),52
演化(evolution),参见:软件演进
演进式交付(Evolutionary Delivery),
参见:增量式开发隐喻
业务规则(business rule)
变更,标出其区域,98
架构的先决条件,46
良好实践表,31-32
子系统设计,85
依赖性(dependency),代码顺序
(code-ordering)
不明显的,348
参数,有效的,349
初始化顺序,348
错误检查,350
概念,347
检查工具,716
明确,348-350
命名子程序,348-349
文档,350
循环(circular),95
隐藏,348
组织代码,348
"已定义的"数据状态(defined data
state),509-510
"已使用的"数据状态(used data
state),509-510
"已销毁的"数据状态(killed data
state),509-510
以人为本的方案,参见:可读性
异常(exceptions),参见:错误处理
C++语言,198-199
Java语言,198-201
Visual Basic语言,198-199,
202
标准化(standardizing)其使
用,202-203
抽象层次(abstraction level)
的规则,199-200
抽象问题,199-200
防御式编程(defensive
programming),核对表,211
非异常的条件(non-
exceptional condition),199
封装(encapsulation),破坏,
200
构造函数(constructor),199
基类(base class),项目特定,
索 引
代码大全(第2版)
941
203
集中报告机制(centralized
reporter),201-202
局部处理(local handling)的
规则,199
可读性(readability),199
空的catch语句块的规则,201
库代码的生成,201
目的,198,199
全部信息(full information)
规则,200
替代方案,203
析构函数(destructor),199
语言比较表,198-199
重构(refactoring),577
资源,212-213
易于维护(ease of maintenance)设
计目标,80
溢出(overflow),整数,293-295
引用符(&),C++,332
隐藏,参见:信息隐藏
隐含实例(implicit instancing),132
隐式声明(implicit declaration),
239-240
隐喻(metaphor),软件
地心说与日心说,10-11
定制,18
耕作,14-15
工具箱(toolbox)法,20
过度引申(overextension),10
基于隐喻的发现,9-10
简单结构与复杂结构,16-17
建造,隐喻,16-19
可读性,13
牡蛎养殖,15-16
抛弃一个,13-14
培植系统,14-15
启发式(heuristic)方法,12
生长系统,15-16
使用建模式(modeling)的隐
喻,9
使用算法式(algorithmic)的
隐喻,11,12
使用隐喻,11-12
示例,13-20
威力,10
相对优点,10,11
项目规模,19
写作代码示例,13-14
要点,21
以计算机为中心与以数据为
中心,11
造组件还是买组件,18
增量开发,15-16
钟摆示例,10
重要性,9-11
组合,20
硬件(hardware)
性能增强,借助,591
依赖,改变,98
用递归(recursion)穿越迷宫的示例,
394-396
用户界面(user interface)
重构数据,576
架构的前期准备,47
子系统设计,85
用户自定义类型(UDT,User Defined
Ty p e),279-280
优化,不成熟的,840;参见:性能
调整
优先级,误导,733
"有一个(has-a)……"的关系,
143
右移(right shift),634
语法,错误,549-550,560,713-714
语句(statement)
不完整的,754-755
长度,753
核对表,774
后续行的布局(endline
layout),754-758
后续行的结尾,756-757
紧密关联的元素,755-756
顺序,参见:直线型代码
重构,572-573,577-578
语句块(block)
纯块,布局风格(pure,layout
style),738-740
单条语句,748-749
定义,443
花括号(brace)书写规则,443
模仿的纯块布局风格,
740-743
条件,明确,443
注释,795-796
语言,编程,参见:编程语言选择
语义检查器(semantics checker),
713-714
语义前缀(semantic prefix),280-281
语义上的耦合(semantic coupling),
102
预处理器(preprocessor)
C++语言,207-208
编写,208
调试辅助(debugging aid),
移除,207-208
目的,718-719
预先做大量的设计(BDUF,Big
Design Up Front),119
员工表现评估,487
原型建立(prototyping),114-115,
468
源代码(source-code)
文档,7
资源,815
源代码(source-code)工具
diff工具,712
grep工具,711
merge(合并)工具,712
版本控制(version control)工
具,715
比较工具,556
编辑器,710-713
尺度报告器(metric reporter),
714
多个文件中查找字符串,
711-712
翻译器(translator),715
分析代码质量,713-714
集成开发环境(IDE),710-711
交叉引用(cross-reference)工
具,713
接口文档,713
结构改组(restructuring)工具,
715
类的继承体系生成器(class
hierarchy generator),713
美化器(beautifier),712
模板,713
数据字典,715
语法检查器(syntax checker),
713-714
语义检查器(semantic
checker),713-714
重构工具,714-715
阅读是一项技能,824
允许的时间,55-56
运行期(runtime),绑定(binding),
253
(Z)
增量集成(incremental integration)
T型(T-Shaped)集成,701
步骤,692
测试驱动,697
策略,概述,694
成果,及早,693
垂直分块(vertical-slice)法,
696
存根(stub),694,696
错误,定位,693
定义,692
方法小结,702
分块(slice)法,698
风险导向(risk-oriented)的 集
成,699
改善对进度的监控,693
索 引
代码大全(第2版)
942
改善客户关系,694
功能导向(feature-oriented)
的集成,700-701
接口定义,695,697
进度的好处,694
类,694,697
三明治(sandwich)策略,
698-699
益处,693-694
资源,708
自下而上策略,697-698
自上而下策略,694-696
自上而下策略的缺点,
695-696
增量开发,隐喻,15-16
折中主义(eclecticism),851-852
针对非功能需求的核对表,42
针对功能需求的核对表,42
整数(integer)数据类型
除法(division)注意事项,
293
核对表,316
取值范围,294
溢出,293-295
运算开销,602
正确性,197,463
正式的技术复审(technical reviews),
467
执行剖测器(execution profilers),
557-558,720
直接访问表(direct access table)
case语句,421-422
保险费率示例,415-416
变化键值(transforming
keys),424
定义,413
对象方法(object approach),
422-423
构造键值(fudging keys),
423-424
键值(keys),423-424
灵活的消息格式,示例,
416-423
设计方法,420
数组(array),414
一个月中的天数示例,
413-414
优点,420
直线型(straight-line)代码
把相关的语句组织在一起,
352-353
不明显的依赖关系,348
参数,明确显示,349
初始化顺序,348
错误检查,350
核对表,353
就近原则,351
明确顺序,要求,347-350
命名子程序,348-349
说明,350
突显依赖关系,348-350
显现依赖关系的组织形式,
348
依赖关系的概念,347
隐藏依赖关系,348
指数表达式(exponential
expressions),631-632
指针(pointer)
&(指针引用符),332
*(指针声明符),332,
334-335,763
->(指针符),328
auto_ptr,333
C++使用指针的指导原则,
332-334
C++示例,325,328-334
C++指针引用,332
C语言,334-335
C语言的字符串操作,299
null,当作警告信号,849
null,删除指针后将其置为
null,330
SAFE_子程序,331-332
sizeof(),335
按引用(by reference)传递,
333
边界检查工具,527
不提供指针的语言,323
初始化,241,244,325-326
地址(address),323,326
调试辅助,208-209
分配,326,330,331
覆盖子程序,331-332
狗牌字段(dog tag field),
326-327
核对表,344
画图,329
简化复杂的指针表达式,329
类型转换,避免,334
链表,删除其中的指针,330
明显的冗余字段,327
内存地址内容的解释,
324-325
内存后备区域(parachutes),
330
内存中的位置,323
内容,解释,324-325
删除,330-331,332
声明,325-326,763
释放,326,330,332
替代方案,332
通过子程序隐藏指针操作,
165
危险性,323,325
先检查再使用,326,331
显式类型,334
限制指针操作,325
相关资源,343
星号规则(*),334-335
要点,344
引起的内存破坏(corruption),
325-327
引用变量,检查,326
用额外的指针变量来提高代
码清晰度,327-329
用垃圾数据覆盖内存区域,
330
与0比较,441
指向的数据类型,324-325
指针作为函数返回值,182
智能指针(smart pointer),334
组成部分,323
质量保证(quality assurance),参见:
软件质量
核对表,70
软件项目的良好实践表,
31-32
需求核对表,42-43
在前期准备中的职责,24
质量门(quality gate),467
智慧工具箱方法,20
智能指针(smart pointer),334
中-低扇出(fan-out)设计目标,81
主要构建实践,核对表,69-70
注释(comment),参见:文档
/* vs. //,790
Javadoc,807,815
版本控制(version control),
811
比例(proportionality),806
编码含义(coded meanings),
802-803
变量,803
标记(marker),787
标准,IEEE,813-814
布局(layout)指导建议,
763-766
参数声明(parameter
declarations),806-807
程序的各部分,809
错误,标注绕弯解决方法
(marking workarounds),
800
代码段落,795-801,816
代码无法表达的信息,788
代码意图(code intent)的层
次,795-796
单行代码,792-795
索 引
代码大全(第2版)
943
法律声明(legal notices),811
风格,违背,801
风格差异,管理,683
富于技巧的代码(tricky
code),798,801
概述代码,787
高效创建,788-791
核对表,774,816-817
集成到开发中,791
接口,类,810
接口,子程序,808
解释(explanatory),786
惊奇,798
空行,周围的,765-766
控制结构(control structure),
804-805,817
烂代码(bad code),568
类(class),810
目的,782
全局变量(global variable),
803,809
绕弯解决(workaround),800
声明(declaration),794,
802-803,816
书本范例(Book Paradigm),
812-813
输出数据,808
输入数据,803,808
数值数据,802
说明代码意图(code intent),
787
说明(description)的长度,
806
苏格拉底式(Socratic)对话,
781-785
算法(algorithm),809
缩进(indentation)指导建议,
764-765
缩写(abbreviation),799
为何与如何(why vs. how),
797-798
维护,220,788-791,794
伪代码(pseudocode),得自
于,220,784,791
未公开的功能特性
(undocumented features),
800
位标志(flags,bit level),803
文件,810-811
先于代码(preceding code)的
原则,798
行尾(endline)注 释 ,793-795
性能考虑,791
循环(loop),804-805
要点,817
与代码距离的指导建议,806
争论,782
种类,786-788
重复代码,786
主要与次要,799-800
资源,815
子程序,805-809,817
自说明的代码(self-
commenting code),796-797
最佳密度(optimum density),
792
作者(authorship),811
专业开发,824-825
专业组织,862
转换数据类型,635
桩对象(stub object),测试,523
装饰器(Decorator)模式,104
状态报告,827
状态变量(status variable)
变化,明确区域,98-99
变量名,266-267
枚举类型,266-267
位一级(bit-level)的含义,
803
用状态变量重写goto语句,
403-404
语义上的耦合(semantic
coupling),102
状态变量,参见:状态变量
准备,参见:前期准备,前期
准备不周全的准备,诱因,25-27
资料库,书籍,参见:软件开发资料
库
资源管理(resource management)
架构,47
释放资源的示例,401-402
子程序(routine)
PPP(伪代码编程过程)核对
表,233-234
编译找错,230-231
变量名,区分,272
不使用,重构,576
布尔判断的好处,165
布局,754,766-768
参数,参见:子程序的参数
测试,222,231,523
测试先行的开发方法,233
查询,重构,574
长度,指导建议,173-174
抽象的好处,164
抽象且可覆盖(abstract and
overridable)的子程序,145
创建in关键字,175-176
创建out关键字,175-176
创建理由,清单,167
创建子程序的正当理由,
164-167
从库中寻求功能,222
从伪代码编码,225-229
错误处理的注意事项,222
错误类,暗示,566
代码调整,639-640
低质量示例,161-163
调用,开销,601
调用的后续行,756
迭代伪代码,225
定义,161
定义子程序要解决的问题,
221
东拼西凑法,233
对象,传递,179,574
对象的成员,传递给子程序,
574
访问,参见:访问子程序
复杂度度量,458
复杂度降低的好处,164
覆盖,156
覆盖后没做任何操作,
146-147
高质量,反例,161-163
公用子程序,使用接口,141
功能的内聚性(functional
cohesion),168-169
规格说明示例,221
过程命名的指导建议,172
过程上的内聚性,170
函数,特别考虑的问题,
181-182
核对表,185,774,780
黑盒(blackbox)测试,502
宏,参见:宏子程序
后条件,221
检查错误,230-231
检查伪代码,224-225
简单,有用,166-167
接口语句,226
局限性,注释,808
具名参数,180
考虑效率问题,165,222-223
可覆盖的子程序与不可覆盖
的子程序,145-146
"可移植性"的好处,165
类的子程序创建步骤,217
类似的参数,顺序,176
临时的内聚性(temporal
cohesion),169
流浪数据,567
逻辑上的内聚性(logical
cohesion),170
命名,171-173,222,277-278,
567
内聚性(cohesion),168-171
内聚性带来的可靠性,168
索 引
代码大全(第2版)
944
内联子程序,184-185
耦合的注意事项,100-102
契约式设计,233
前条件,221
嵌套层次很深,164
强度,168
巧合的内聚性,170
设计,86,220-225
设置代码,重构,568,569
声明,226
事件处理器,170
收尾步骤,232
输入-修改-输出的参数顺序,
174-175
数据的状态,509
数据结构,224
顺序上的内聚性(sequential
cohesion),168
说明,178,180
算法选择,223,573
缩进,766-768
"通过子程序隐藏指针"的好
处,165
通信上的内聚性
(communicational
cohesion),169
头部注释(header comment),
223
伪代码编写步骤,223-224
伪代码变为高层次的注释,
226-227
文件,布局,772
先决条件,221
相似,重构,574
向下转型(down cast)的对象,
574
消除错误,231
小型子程序与大型子程序作
比,166,173-174
行尾布局,767
要点,186,234
"以对象作为参数"的抽象,
179,574
"隐藏顺序"的好处,165
用函数完成计算之示例,
166-167
在脑海中检查程序中的错误,
230
"支持子类化"的好处,165
重复步骤,232
重复的好处,164-165
重构,229,573-575,578,
582
重要性,163
注释,805-809,817
转到伪代码编程过程,
232-233
转换为类,准绳,573
子程序返回,多处返回,
391-393
"子程序规模"作为重构指
示,565-566
子程序命名的描述性指导建
议,171
子程序内部的设计,87
子程序中的错误,对长度而
言,173
子程序中的多处返回,
391-393
子程序中的空行,766
走查(walk-through)代码,
231
子程序的参数
C语言函数库参数顺序,175
Java语言,176-177
Visual Basic语言,180
按引用传递与按值传递,333
变量,用作参数,176-177
"参数列表规模"作为重构指
示,566
常量前缀,176,177,274
抽象和对象参数,179
出错变量,176
传递,类型,333
创建in关键字,175-176
创建out关键字,175-176
对象,传递,179
个数,限制,178
核对表,185
结构型参数,322
枚举类型,303
命名,178,180,274,277,
278,279
全局变量,336
确保实际参数与形式参数相
匹配,180
实际参数,与形式参数匹配,
180
使用所有参数的规则,176
输入-修改-输出的顺序,
174-175
顺序,174-176
说明,178
行为取决于参数的子程序,
574
形式参数,与实际参数匹配,
180
依赖关系,明确,349
在子程序中使用的指导原则,
174-180
指针的星号(*)规则,334-335
重构,571,573
注释,806-807
状态,176
子程序中的多处返回,391-393
子过程,161;参见:子程序
子系统设计层,82-85
字符(character)数据类型
C语言,299-301
Unicode,298,299
核对表,316-317
神秘的(字面(literal))字符 ,
297-298
数组与字符串指针,299
转换(conversion)策略,299
字符集(character set),298
字符串(string)数据类型
C语言,299-301
Unicode,298,299
本地化(localization),298
初始化,300
核对表,316-317
神秘的(字面(literal))字符
串,297-298
索引,298,299-300,627
与内存有关的问题,298,300
指针与字符数组,299
转换(conversion)策略,299
字符集(character set),298
字符串指针,299
字符数组(character array),299-300;
参见:字符串数据类型
字面量(literal)数据,297-298,
308-309
自上而下的集成,694-696
自动化测试(automated testing),
528-529
自然形成的本质,设计过程,76
自上而下的设计方法,111-113
自说明代码(self-documenting
code),778-781,796-797
自下而上的集成,697-698
自下而上的设计方法,112-113
走查(walk-through),492-493,
495-496
组合(Composite)模式,104
组件(components),购买,18,51
组件测试(component testing),499
最大的正常局面(maximum normal
configuration),515
最小的正常局面(minimum normal
configuration),51
索 引
代码大全(第2版)
945
索 引
代码大全(第2版)
946
索 引
代码大全(第2版)
947
索 引
代码大全(第2版)
948
·上一篇：组织的设计
·下一篇：智力测验分数解释的发展趋势X