1.1 C++基础 1
1.1.1 必不可少的“Hello，World” 1
目录 1
译者序 1
前言 1
作者简介 1
第一部分 专业C++程序设计概述 1
第1章 C++快速入门 1
1.1.2 命名空间 4
1.1.3 变量 5
1.1.4 操作符 7
1.1.5 类型 9
1.1.6 条件语句 10
1.1.7 循环 13
1.1.9 函数 14
1.1.8 数组 14
1.1.10 结束语 15
1.2.1 指针和动态内存 16
1.2 C++进阶 16
1.2.2 C++中的字符串 18
1.2.3 引用 20
1.2.4 异常 21
1.2.5 const的多重用途 22
1.3 作为一种面向对象语言的C++ 23
1.4 你的第一个实用的C++程序 25
1.4.2 Employee类 26
1.4.1 一个员工记录系统 26
1.4.3 Database类 30
1.4.4 用户界面 34
1.5 小结 36
1.4.5 对程序的评价 36
2.1 什么是编程设计 37
第2章 设计专业的C++程序 37
2.2 编程设计的重要性 38
2.3 C++设计有什么不同之处 39
2.4.1 抽象 40
2.4 C++设计的两个原则 40
2.4.2 重用 41
2.5.2 设计步骤 43
2.5.1 需求 43
2.5 设计一个象棋程序 43
2.6 小结 47
3.1.1 我是在以过程性思维思考吗 48
3.1 面向对象的世界观 48
第3章 基于对象的设计 48
3.1.2 面向对象思想 49
3.1.3 身处对象世界中 51
3.1.4 对象关系 52
3.1.5 抽象 61
3.2 小结 63
4.1.1 有关术语 64
4.1 重用代码 64
第4章 基于库和模式的设计 64
4.1.2 决定是否重用代码 65
4.1.3 重用代码的策略 67
4.1.5 开源库 70
4.1.4 捆绑第三方应用 70
4.1.6 C++标准库 71
4.2.1 设计技术 81
4.2 利用模式和技术完成设计 81
4.2.2 设计模式 82
4.3 小结 83
5.1 重用方法论 84
第5章 重用设计 84
5.2.1 使用抽象 85
5.2 如何设计可重用的代码 85
5.2.2 适当地建立代码结构以优化重用 86
5.2.3 设计可用的接口 89
5.2.4 协调一般性和易用性 93
5.3 小结 94
6.1 为什么需要过程 95
第6章 充分利用软件工程方法 95
6.2.1 分阶段模型和瀑布模型 96
6.2 软件生命期模型 96
6.2.2 螺旋方法 98
6.2.3 统一开发过程 100
6.3.1 极限编程（XP） 101
6.3 软件工程方法论 101
6.4 建立自己的过程和方法论 104
6.3.2 软件triage 104
6.5 小结 105
6.4.4 不要做叛逃者 105
6.4.1 以开放的心态接纳新思想 105
6.4.2 汇总新思想 105
6.4.3 明确哪些可行，哪些不可行 105
7.1.2 保持清晰 107
7.1.1 提前考虑 107
第二部分 编写C++代码方式 107
第7章 好的编码风格 107
7.1 为什么代码看上去要好 107
7.2.1 写注释的原因 108
7.2 为代码加注释 108
7.1.3 好的代码风格包括哪些因素 108
7.2.2 注释风格 111
7.3.1 通过重构来分解 115
7.3 分解 115
7.2.3 本书中的注释 115
7.3.2 根据设计来分解 116
7.4.1 选择一个好名字 117
7.4 命名 117
7.3.3 本书中的分解 117
7.4.2 命名约定 118
7.5.1 使用常量 119
7.5 合理地使用语言特性 119
7.5.4 使用定制异常 120
7.5.3 使用引用而不是指针 120
7.5.2 利用const变量 120
7.6.1 有关大括号对齐的争论 121
7.6 格式化 121
7.7 风格方面的难题 122
7.6.3 空格和制表符 122
7.6.2 考虑空格和小括号 122
7.8 小结 123
8.2.1 类定义 124
8.2 编写类 124
第8章 掌握类和对象 124
8.1 电子表格示例 124
8.2.2 定义方法 127
8.2.3 使用对象 130
8.3.1 对象创建 131
8.3 对象生命期 131
8.3.2 对象撤销 140
8.3.3 对象赋值 141
8.3.4 区别复制和赋值 143
8.4 小结 144
9.1.1 Spreadsheet类 145
9.1 对象中的动态内存分配 145
第9章 精通类和对象 145
9.1.3 处理复制和赋值 147
9.1.2 用析构函数释放内存 147
9.2.1 静态数据成员 154
9.2 不同类型的数据成员 154
9.2.2 const数据成员 156
9.2.3 引用数据成员 157
9.3.1 静态方法 158
9.3 深入了解方法 158
9.2.4 const引用数据成员 158
9.3.2 const方法 159
9.3.3 方法重载 161
9.3.4 默认参数 162
9.3.5 内联方法 163
9.4 嵌套类 164
9.6.1 实现加法 166
9.6 操作符重载 166
9.5 友元 166
9.6.2 重载算术操作符 170
9.6.3 重载比较操作符 172
9.7 方法和成员指针 174
9.6.4 利用操作符重载构建类型 174
9.8 构建抽象类 175
9.9 小结 178
10.1.1 扩展类 179
10.1 使用继承构建类 179
第10章 探索继承技术 179
10.1.2 覆盖方法 182
10.2.1 类WeatherPrediction 184
10.2 继承以实现重用 184
10.2.2 在子类中增加功能 185
10.3.1 父构造函数 187
10.3 考虑父类 187
10.2.3 在子类中进行功能替换 187
10.3.2 父析构函数 189
10.3.3 引用父类的数据 191
10.3.4 向上类型强制转换和向下类型强制转换 192
10.4.1 Spreadsheet的返回结果 193
10.4 继承以实现多态 193
10.4.3 电子表格单元格的基类 194
10.4.2 设计多态电子表格单元格 194
10.4.4 各个子类 196
10.4.5 充分利用多态 198
10.4.6 将来的考虑 199
10.5.1 从多个类继承 200
10.5 多重继承 200
10.5.2 命名冲突与二义基类 201
10.6.1 改变覆盖方法的特性 203
10.6 继承技术中有趣而隐蔽的问题 203
10.6.2 覆盖方法的特殊情况 206
10.6.3 复制构造函数与相等操作符 212
10.6.4 关键字virtual的真相 213
10.6.5 运行时类型工具 215
10.6.7 虚基类 217
10.6.6 非公共继承 217
10.7 小结 218
11.1 模板概述 219
第11章 利用模板编写通用代码 219
11.2.1 编写类模板 220
11.2 类模板 220
11.2.2 编译器如何处理模板 227
11.2.3 模板代码在文件之间的分布 228
11.2.4 模板参数 229
11.2.5 方法模板 231
11.2.6 模板类特殊化 235
11.2.7 从模板类派生子类 239
11.3 函数模板 240
11.2.8 继承与特殊化的区别 240
11.3.1 函数模板特殊化 241
11.3.2 函数模板的重载 242
11.3.3 类模板的友元函数模板 243
11.4.1 关于模板参数的更多知识 244
11.4 高级模板 244
11.4.2 模板类的部分特殊化 251
11.4.3 用重载模板函数部分特殊化 256
11.4.4 模板递归 257
11.5 小结 264
12.1.1 引用变量 265
12.1 引用 265
第12章 理解C++疑难问题 265
12.1.3 引用参数 267
12.1.2 引用数据成员 267
12.1.5 采用引用还是指针 268
12.1.4 引用返回类型 268
12.2.1 关键字const 270
12.2 关键字疑点 270
12.2.2 关键字static 273
12.3.1 typedef 276
12.3 类型与类型强制转换 276
12.2.3 非局部变量的初始化顺序 276
12.3.2 类型强制转换 277
12.4 解析作用域 281
12.5 头文件 282
12.6.1 变量长度参数列表 283
12.6 C实用工具 283
12.7 小结 285
12.6.2 预处理宏 285
13.1.1 如何描述内存 287
13.1 使用动态内存 287
第三部分 掌握C++高级特性 287
第13章 有效的内存管理 287
13.1.2 内存的分配与撤销 289
13.1.3 数组 291
13.1.4 使用指针 297
13.2.1 数组即指针 299
13.2 数组与指针的对应 299
13.3 动态字符串 300
13.2.2 指针并非都是数组 300
13.3.1 C风格的字符串 301
13.3.2 字符串直接量 302
13.3.3 C++的字符串类 303
13.4.1 指针运算 304
13.4 低级的内存操作 304
13.4.3 垃圾回收 305
13.4.2 自定义内存管理 305
13.4.5 函数指针 306
13.4.4 对象池 306
13.5.1 字符串空间分配不足 308
13.5 常见的内存陷阱 308
13.5.2 内存泄漏 309
13.5.3 二次删除与无效指针 311
13.6 小结 312
13.5.4 访问越界指针 312
14.1.2 流的源与目的 313
14.1.1 到底什么是流 313
第14章 揭开C++ I/O的神秘面纱 313
14.1 使用流 313
14.1.3 流输出 314
14.1.4 流输入 317
14.1.5 输入与输出对象 321
14.2 字符串流 323
14.3 文件流 324
14.3.1 使用seek（）与tell（） 325
14.4 双向I/O 327
14.3.2 链接流 327
14.5.2 非西方字符集 329
14.5.1 宽字符 329
14.5 国际化 329
14.5.3 本地化环境与方面 330
14.6 小结 332
15.1.1 到底什么是异常 333
15.1 错误和异常 333
第15章 处理错误 333
15.1.2 C++中的异常为什么好 334
15.2 异常机制 335
15.1.4 我们的建议 335
15.1.3 C++中的异常为什么不好 335
15.2.1 抛出和捕获异常 336
15.2.2 异常类型 338
15.2.3 抛出和捕获多个异常 339
15.2.4 未捕获的异常 342
15.2.5 抛出列表 343
15.3.1 标准异常层次体系 346
15.3 异常和多态 346
15.3.2 按类层次捕获异常 348
15.3.3 编写自己的异常类 349
15.4 栈展开和清除 351
15.4.2 使用智能指针 353
15.4.1 捕获、清除和重新抛出 353
15.5.1 内存分配错误 354
15.5 常见的错误处理问题 354
15.5.2 构造函数中的错误 356
15.6 综合 357
15.5.3 析构函数中的错误 357
15.7 小结 359
16.1 操作符重载概述 361
第16章 重载C++操作符 361
第四部分 确保无错代码 361
16.1.3 操作符重载中的选择 362
16.1.2 操作符重载的限制 362
16.1.1 为什么要重载操作符 362
16.1.5 可重载操作符小结 364
16.1.4 不应重载的操作符 364
16.2.1 重载一元减和一元加 367
16.2 重载算术操作符 367
16.2.2 重载自增和自减 368
16.4 重载插入和析取操作符 369
16.3 重载位操作符和二元逻辑操作符 369
16.5 重载下标操作符 371
16.5.1 利用operator［ ］提供只读访问 373
16.6 重载函数调用操作符 375
16.5.2 非整数数组索引 375
16.7 重载解除引用操作符 377
16.7.1 实现operator＊ 378
16.7.3 到底什么是operator－＞＊ 379
16.7.2 实现operator－＞ 379
1 6.8编写转换操作符 380
16.8.1 转换操作符的二义性问题 381
16.8.2 布尔表达式的转换 382
16.9 重载内存分配和撤销操作符 383
16.9.1 new和delete究竟如何工作 384
16.9.2 重载operator new和operator delete 385
16.9.3 重载带额外参数的operator new和operator delete 387
16.10 小结 389
17.1.2 两类程序 390
17.1.1 实现高效的两种方法 390
第17章 编写高效的C++程序 390
17.1 性能和效率概述 390
17.2 语言级效率 391
17.1.3 C++是一种低效语言吗 391
17.2.1 高效地处理对象 392
17.2.2 不要过度使用高开销的语言特性 394
17.2.3 使用内联方法和函数 395
17.3.1 尽可能缓存 396
17.3 设计级效率 396
17.3.2 使用对象池 397
17.4 测评分析 402
17.3.3 使用线程池 402
17.5 小结 410
18.1.1 体系结构问题 411
18.1 跨平台开发 411
第18章 开发跨平台和跨语言的应用 411
18.1.2 实现问题 413
18.1.3 特定于平台的特性 414
18.2.2 转换模式 415
18.2.1 混合C和C++ 415
18.2 跨语言开发 415
18.2.3 与C代码的链接 418
18.2.4 利用JNI混合Java和C++ 419
18.2.5 C++与Perl和Shell脚本的混合 421
18.3 小结 424
18.2.6 C++与汇编代码的混合 424
19.1.2 bug的生命期 425
19.1.1 谁来负责测试 425
第19章 熟练地测试 425
19.1 质量控制 425
19.1.3 bug跟踪工具 427
19.2.1 单元测试的方法 428
19.2 单元测试 428
19.2.2 单元测试过程 429
19.2.3 实战单元测试 431
19.3.1 集成测试 439
19.3 高级测试 439
19.3.2 系统测试 440
19.4 成功测试的提示 441
19.3.3 回归测试 441
19.5 小结 442
20.3 避免bug 443
20.2 bug分类 443
第20章 征服调试 443
20.1 调试基本法则 443
20.4.1 错误日志 444
20.4 找出bug的方法 444
20.4.2 调试轨迹 445
20.4.3 断言 455
20.5.2 调试可再生bug 456
20.5.1 再生bug 456
20.5 调试技术 456
20.5.4 调试内存问题 457
20.5.3 调试不可再生bug 457
20.5.6 调试示例：文章引用 461
20.5.5 调试多线程程序 461
20.6 小结 472
20.5.7 从ArticleCitations示例学到的教训 472
21.1 容器概述 473
第21章 深入STL：容器和迭代器 473
21.1.2 异常和错误检查 474
21.1.1 元素需求 474
21.1.3 迭代器 475
21.2.1 vector 476
21.2 顺序容器 476
21.2.2 vector＜bool＞特殊化 492
21.2.4 list 493
21.2.3 deque 493
21.3.1 queue 496
21.3 容器适配器 496
21.3.2 priority_queue 499
21.3.3 stack 502
21.4.1 pair工具类 503
21.4 关联容器 503
21.4.2 map 504
21.4.3 multimap 511
21.4.4 set 515
21.4.5 multiset 517
21.5 其他容器 517
21.5.1 数组作为STL容器 517
21.5.2 string作为STL容器 518
21.5.3 流作为STL容器 519
21.5.4 bitset 519
21.6 小结 524
第五部分 使用库和模式 525
第22章 掌握STL算法和函数对象 525
22.1 算法概述 525
22.1.1 find（）和find_if（）算法 526
22.1.2 accumulate（）算法 528
22.2.1 算术函数对象 529
22.2 函数对象 529
22.2.2 比较函数对象 530
22.2.3 逻辑函数对象 531
22.2.4 函数对象适配器 531
22.2.5 编写自己的函数对象 534
22.3 算法细节 535
22.3.1 工具算法 536
22.3.2 非修改算法 536
22.3.3 修改算法 542
22.3.4 排序算法 545
22.3.5 集合算法 547
22.4.1 选民注册审计问题描述 549
22.4.2 auditVoterRolls（）函数 549
22.4 算法和函数对象示例：选民注册审计 549
22.4.3 getDuplicates（）函数 550
22.4.4 RemoveNames函数对象 551
22.4.5 NameInList函数对象 552
22.4.6 测试auditVoterRolls（）函数 553
22.5 小结 554
第23章 定制和扩展STL 555
23.1 分配器 555
23.2 迭代器适配器 556
23.2.1 逆序迭代器 556
23.2.2 流迭代器 557
23.2.3 插入迭代器 557
23.3.1 为什么要扩展STL 559
23.3.2 编写STL算法 559
23.3 扩展STL 559
23.3.3 编写一个STL容器 561
23.4 小结 587
24.1 分布式计算的魅力 588
24.1.1 分布以获得可扩展性 588
第24章 探讨分布式对象 588
24.1.4 分布式内容 589
24.1.3 分布以获得集中性 589
24.1.5 分布式vs网络式 589
24.1.2 分布以获得可靠性 589
24.2 分布式对象 590
24.2.1 串行化和编组 590
24.2.2 远程过程调用 593
24.3 CORBA 595
24.3.1 接口定义语言 595
24.3.2 实现类 597
24.3.3 使用对象 598
24.4 XML 602
24.4.1 XML快速入门 602
24.4.2 XML作为一种分布式对象技术 604
24.4.3 用C++生成和解析XML 604
24.4.4 XML验证 612
24.4.5 用XML构建分布式对象 613
24.4.6 SOAP（简单对象访问协议） 616
24.5 小结 618
25.1 “我想不起来如何…” 619
25.1.1 ……编写一个类 619
第25章 结合技术和框架 619
25.1.2 ……派生一个现有类 621
25.1.3 ……抛出和捕获异常 622
25.1.4 ……读文件 622
25.1.5 ……写文件 623
25.1.6 ……编写模板类 623
25.2 还有更好的办法 625
25.2.1 带引用计数的智能指针 625
25.2.2 双重分派 630
25.2.3 混合类 635
25.3 面向对象框架 637
25.3.1 使用框架 637
25.3.2 模型-视图-控制器模式 638
25.4 小结 639
26.1 单例模式 640
26.1.1 举例：日志机制 640
第26章 应用设计模式 640
26.1.2 单例的实现 641
26.1.3 使用单例 645
26.2 工厂模式 646
26.2.1 举例：汽车工厂模拟 646
26.2.2 实现工厂 648
26.2.3 使用工厂 650
26.2.4 工厂的其他使用 651
26.3.1 举例：隐藏网络连通性问题 652
26.3.2 实现代理 652
26.3 代理模式 652
26.4 适配器模式 653
26.4.1 举例：适配一个XML库 653
26.3.3 使用代理 653
26.4.2 适配器的实现 654
26.4.3 使用适配器 657
26.5 装饰器模式 658
26.5.1 举例：定义网页中的样式 658
26.5.2 装饰器的实现 659
26.5.3 使用装饰器 660
26.6.1 举例：事件处理 661
26.6.2 职责链的实现 661
26.6 职责链模式 661
26.6.3 使用职责链 662
26.7 观察者模式 662
26.7.1 举例：事件处理 663
26.7.2 实现观察者 663
26.7.3 使用观察者 664
26.8 小结 665
附录 666
附录A C++面试宝典 666
附录B 参考书目 681