.1.6.1 给C程序员的建议 13
1.6.2 给C++程序员的建议 13
1.7 有关在C++里编程的思考 14
1.8 忠告 15
1.9 参考文献 16
第2章 C++概览 19
2.1 为什么是C++ 19
2.2 程序设计范型 19
2.3 过程式程序设计 20
2.3.1 变量和算术 21
2.3.2 检测和循环 22
2.3.3 指针和数组 23
2.4 模块程序设计 23
2.4.1 分别编译 24
2.4.2 异常处理 25
2.5 数据抽象 26
2.5.1 定义类型的模块 27
2.5.2 用户定义类型 28
2.5.3 具体类型 29
2.5.4 抽象类型 31
2.5.5 虚函数 33
2.6 面向对象的程序设计 33
2.6.1 具体类型的问题 33
2.6.2 类层次结构 34
2.7 通用型程序设计 36
2.7.1 容器 36
2.7.2 通用型算法 37
2.8 附言 38
2.9 忠告 39
第3章 标准库概览 40
3.1 引言 40
3.2 Hello, world！ 40
3.3 标准库名字空间 41
3.4 输出 41
3.5 字符串 42
3.5.1 C风格的字符串 44
3.6 输入 44
3.7 容器 46
3.7.1 向量—vector 46
3.7.2 范围检查 47
3.7.3 表—list 48
3.7.4 映射—map 49
3.7.5 标准容器 49
3.8 算法 50
3.8.1 迭代器的使用 51
3.8.2 迭代器类型 52
3.8.3 迭代器和I/O 53
3.8.4 遍历和谓词 54
3.8.5 使用成员函数的算法 56
3.8.6 标准库算法 56
3.9 数学 57
3.9.1 复数 57
3.9.2 向量算术 57
3.9.3 基本数值支持 58
3.10 标准库功能 58
3.11 忠告 58
第一部分 基本功能
第4章 类型和声明 63
4.1 类型 63
4.1.1 基本类型 64
4.2 布尔量 64
4.3 字符类型 65
4.3.1 字符文字量 66
4.4 整数类型 66
4.4.1 整数文字量 66
4.5 浮点类型 67
4.5.1 浮点文字量 67
4.6 大小 68
4.7 void 69
4.8 枚举 69
4.9 声明 71
4.9.1 声明的结构 72
4.9.2 声明多个名字 73
4.9.3 名字 73
4.9.4 作用域 74
4.9.5 初始化 75
4.9.6 对象和左值 76
4.9.7 typedef 76
4.10 忠告 77
4.11 练习 77
第5章 指针、数组和结构 79
5.1 指针 79
5.1.1 零 80
5.2 数组 80
5.2.1 数组初始化 80
5.2.2 字符串文字量 81
5.3 到数组的指针 83
5.3.1 在数组里漫游 83
5.4 常量 85
5.4.1 指针和常量 87
5.5 引用 88
5.6 指向void的指针 90
5.7 结构 91
5.7.1 类型等价 94
5.8 忠告 94
5.9 练习 94
第6章 表达式和语句 96
6.1 一个桌面计算器 96
6.1.1 分析器 96
6.1.2 输入函数 100
6.1.3 低级输入 102
6.1.4 错误处理 103
6.1.5 驱动程序 104
6.1.6 头文件 104
6.1.7 命令行参数 105
6.1.8 有关风格的注记 106
6.2 运算符概览 107
6.2.1 结果 109
6.2.2 求值顺序 110
6.2.3 运算符优先级 110
6.2.4 按位逻辑运算符 111
6.2.5 增量和减量 112
6.2.6 自由存储 113
6.2.7 显式类型转换 116
6.2.8 构造函数 117
6.3 语句概览 118
6.3.1 声明作为语句 119
6.3.2 选择语句 119
6.3.3 迭代语句 122
6.3.4 goto 123
6.4 注释和缩进编排 123
6.5 忠告 125
6.6 练习 125
第7章 函数 128
7.1 函数声明 128
7.1.1 函数定义 128
7.1.2 静态变量 129
7.2 参数传递 130
7.2.1 数组参数 131
7.3 返回值 132
7.4 重载函数名 133
7.4.1 重载和返回类型 135
7.4.2 重载与作用域 135
7.4.3 手工的歧义性解析 135
7.4.4 多参数的解析 136
7.5 默认参数 137
7.6 未确定数目的参数 138
7.7 指向函数的指针 139
7.8 宏 143
7.8.1 条件编译 145
7.9 忠告 145
7.10 练习 146
第8章 名字空间和异常 148
8.1 模块化和界面 148
8.2 名字空间 150
8.2.1 带限定词的名字 151
8.2.2 使用声明 152
8.2.3 使用指令 153
8.2.4 多重界面 154
8.2.5 避免名字冲突 157
8.2.6 名字查找 159
8.2.7 名字空间别名 159
8.2.8 名字空间组合 160
8.2.9 名字空间和老代码 163
8.3 异常 166
8.3.1 抛出和捕捉 167
8.3.2 异常的辨识 168
8.3.3 在计算器中的异常 169
8.4 忠告 173
8.5 练习 173
第9章 源文件和程序 175
9.1 分别编译 175
9.2 连接 176
9.2.1 头文件 178
9.2.2 标准库头文件 179
9.2.3 单一定义规则 180
9.2.4 与非C++代码的连接 182
9.2.5 连接与指向函数的指针 184
9.3 使用头文件 184
9.3.1 单一头文件 184
9.3.2 多个头文件 187
9.3.3 包含保护符 191
9.4 程序 192
9.4.1 非局部变量的初始化 192
9.5 忠告 194
9.6 练习 194
第二部分 抽象机制
第10章 类 199
10.1 引言 199
10.2 类 199
10.2.1 成员函数 200
10.2.2 访问控制 201
10.2.3 构造函数 202
10.2.4 静态成员 203
10.2.5 类对象的复制 204
10.2.6 常量成员函数 205
10.2.7 自引用 205
10.2.8 结构和类 208
10.2.9 在类内部的函数定义 210
10.3 高效的用户定义类型 210
10.3.1 成员函数 212
10.3.2 协助函数 214
10.3.3 重载的运算符 215
10.3.4 具体类型的意义 215
10.4 对象 216
10.4.1 析构函数 216
10.4.2 默认构造函数 217
10.4.3 构造和析构 218
10.4.4 局部变量 218
10.4.5 自由存储 220
10.4.6 类对象作为成员 221
10.4.7 数组 223
10.4.8 局部静态存储 224
10.4.9 非局部存储 225
10.4.10 临时对象 226
10.4.11 对象的放置 228
10.4.12 联合 229
10.5 忠告 230
10.6 练习 230
第11章 运算符重载 233
11.1 引言 233
11.2 运算符函数 234
11.2.1 二元和一元运算符 235
11.2.2 运算符的预定义意义 236
11.2.3 运算符和用户定义类型 236
11.2.4 名字空间里的运算符 237
11.3 一个复数类型 238
11.3.1 成员运算符和非成员运算符 238
11.3.2 混合模式算术 239
11.3.3 初始化 240
11.3.4 复制 241
11.3.5 构造函数和转换 242
11.3.6 文字量 243
11.3.7 另一些成员函数 243
11.3.8 协助函数 244
11.4 转换运算符 245
11.4.1 歧义性 246
11.5 友元 248
11.5.1 友元的寻找 249
11.5.2 友元和成员 250
11.6 大型对象 251
11.7 基本运算符 253
11.7.1 显式构造函数 253
11.8 下标 255
11.9 函数调用 256
11.10 间接 257
11.11 增量和减量 259
11.12 一个字符串类 260
11.13 忠告 265
11.14 练习 265
第12章 派生类 268
12.1 引言 268
12.2 派生类 269
12.2.1 成员函数 271
12.2.2 构造函数和析构函数 272
12.2.3 复制 273
12.2.4 类层次结构 273
12.2.5 类型域 274
12.2.6 虚函数 276
12.3 抽象类 278
12.4 类层次结构的设计 280
12.4.1 一个传统的层次结构 280
12.4.2 抽象类 283
12.4.3 其他实现方式 285
12.4.4 对象创建的局部化 287
12.5 类层次结构和抽象类 289
12.6 忠告 289
12.7 练习 289
第13章 模板 292
13.1 引言 292
13.2 一个简单的String模板 293
13.2.1 定义一个模板 294
13.2.2 模板实例化 295
13.2.3 模板参数 296
13.2.4 类型等价 296
13.2.5 类型检查 297
13.3 函数模板 298
13.3.1 函数模板的参数 299
13.3.2 函数模板的重载 300
13.4 用模板参数描述策略 302
13.4.1 默认模板参数 303
13.5 专门化 304
13.5.1 专门化的顺序 306
13.5.2 模板函数的专门化 307
13.6 派生和模板 308
13.6.1 参数化和继承 309
13.6.2 成员模板 310
13.6.3 继承关系 311
13.7 源代码组织 312
13.8 忠告 314
13.9 练习 314
第14章 异常处理 316
14.1 错误处理 316
14.1.1 关于异常的其他观点 318
14.2 异常的结组 318
14.2.1 派生的异常 319
14.2.2 多个异常的组合 321
14.3 捕捉异常 321
14.3.1 重新抛出 322
14.3.2 捕捉所有异常 322
14.4 资源管理 324
14.4.1 构造函数和析构函数的使用 325
14.4.2 auto_ptr 326
14.4.3 告诫 328
14.4.4 异常和new 328
14.4.5 资源耗尽 329
14.4.6 构造函数里的异常 331
14.4.7 析构函数里的异常 332
14.5 不是错误的异常 333
14.6 异常的描述 334
14.6.1 对异常描述的检查 335
14.6.2 未预期的异常 336
14.6.3 异常的映射 336
14.7 未捕捉的异常 338
14.8 异常和效率 339
14.9 处理错误的其他方式 340
14.10 标准异常 342
14.11 忠告 344
14.12 练习 344
第15章 类层次结构 346
15.1 引言和概述 346
15.2 多重继承 346
15.2.1 歧义性解析 348
15.2.2 继承和使用声明 349
15.2.3 重复的基类 350
15.2.4 虚基类 352
15.2.5 使用多重继承 354
15.3 访问控制 357
15.3.1 保护成员 359
15.3.2 对基类的访问 360
15.4 运行时类型信息 361
15.4.1 dynamic_cast 363
15.4.2 在类层次结构中漫游 365
15.4.3 类对象的构造与析构 367
15.4.4 typeid和扩展的类型信息 368
15.4.5 RTTI的使用和误用 370
15.5 指向成员的指针 371
15.5.1 基类和派生类 373
15.6 自由存储 374
15.6.1 数组分配 375
15.6.2 虚构造函数 376
15.7 忠告 377
15.8 练习 377
第三部分 标 准 库
第16章 库组织和容器 381
16.1 标准库的设计 381
16.1.1 设计约束 382
16.1.2 标准库组织 383
16.1.3 语言支持 385
16.2 容器设计 386
16.2.1 专门化的容器和迭代器 386
16.2.2 有基类的容器 388
16.2.3 STL容器 391
16.3 向量 392
16.3.1 类型 393
16.3.2 迭代器 394
16.3.3 元素访问 395
16.3.4 构造函数 396
16.3.5 堆栈操作 399
16.3.6 表操作 401
16.3.7 元素定位 403
16.3.8 大小和容量 404
16.3.9 其他成员函数 406
16.3.10 协助函数 406
16.3.11 vector[bool] 407
16.4 忠告 407
16.5 练习 408
第17章 标准容器 409
17.1 标准容器 409
17.1.1 操作综述 409
17.1.2 容器综述 412
17.1.3 表示 413
17.1.4 对元素的要求 413
17.2 序列 416
17.2.1 向量—vector 416
17.2.2 表—list 416
17.2.3 双端队列—deque 420
17.3 序列适配器 421
17.3.1 堆栈—stack 421
17.3.2 队列—queue 422
17.3.3 优先队列—priority_queue 423
17.4 关联容器 425
17.4.1 映射—map 425
17.4.2 多重映射—multimap 433
17.4.3 集合—set 434
17.4.4 多重集合—multiset 435
17.5 拟容器 435
17.5.1 串—string 435
17.5.2 值向量—valarray 435
17.5.3 位集合—bitset 435
17.5.4 内部数组 439
17.6 定义新容器 439
17.6.1 散列映射—hash_map 440
17.6.2 表示和构造 441
17.6.3 其他散列关联容器 446
17.7 忠告 446
17.8 练习 446
第18章 算法和函数对象 449
18.1 引言 449
18.2 标准库算法综述 449
18.3 序列和容器 453
18.3.1 输入序列 453
18.4 函数对象 454
18.4.1 函数对象的基类 456
18.4.2 谓词 456
18.4.3 算术函数对象 458
18.4.4 约束器、适配器和否定器 458
18.5 非修改性序列算法 463
18.5.1 对每个做—for_each 463
18.5.2 查找族函数 464
18.5.3 计数 465
18.5.4 相等和不匹配 466
18.5.5 搜索 467
18.6 修改性序列算法 467
18.6.1 复制 468
18.6.2 变换 469
18.6.3 惟一化 471
18.6.4 取代 473
18.6.5 删除 474
18.6.6 填充和生成 474
18.6.7 反转和旋转 475
18.6.8 交换 476
18.7 排序的序列 476
18.7.1 排序 476
18.7.2 二分检索 477
18.7.3 归并 478
18.7.4 划分 479
18.7.5 序列上的集合运算 479
18.8 堆 480
18.9 最小和最大 481
18.10 排列 482
18.11 C风格算法 482
18.12 忠告 483
18.13 练习 483
第19章 迭代器和分配器 485
19.1 引言 485
19.2 迭代器和序列 485
19.2.1 迭代器的操作 486
19.2.2 迭代器特征类—iterator_traits 487
19.2.3 迭代器类别 488
19.2.4 插入器 490
19.2.5 反向迭代器 491
19.2.6 流迭代器 492
19.3 带检查迭代器 495
19.3.1 异常、容器和算法 499
19.4 分配器 500
19.4.1 标准分配器 500
19.4.2 一个用户定义分配器 503
19.4.3 广义的分配器 505
19.4.4 未初始化的存储 506
19.4.5 动态存储 508
19.4.6 C风格的分配 509
19.5 忠告 510
19.6 练习 510
第20章 串 511
20.1 引言 511
20.2 字符 511
20.2.1 字符特征类—char_traits 512
20.3 基础串类—basic_string 513
20.3.1 类型 514
20.3.2 迭代器 515
20.3.3 元素访问 516
20.3.4 构造函数 516
20.3.5 错误 517
20.3.6 赋值 518
20.3.7 到C风格字符串的转换 519
20.3.8 比较 521
20.3.9 插入 522
20.3.10 拼接 523
20.3.11 查找 524
20.3.12 替换 525
20.3.13 子串 526
20.3.14 大小和容量 527
20.3.15 I/O操作 527
20.3.16 交换 528
20.4 C标准库 528
20.4.1 C风格字符串 528
20.4.2 字符分类 530
20.5 忠告 530
20.6 练习 531
第21章 流 533
21.1 引言 533
21.2 输出 534
21.2.1 输出流 535
21.2.2 内部类型的输出 536
21.2.3 用户定义类型的输出 538
21.3 输入 540
21.3.1 输入流 540
21.3.2 内部类型的输入 540
21.3.3 流状态 542
21.3.4 字符的输入 544
21.3.5 用户定义类型的输入 546
21.3.6 异常 547
21.3.7 流的联结 548
21.3.8 哨位 549
21.4 格式化 550
21.4.1 格式状态 550
21.4.2 整数输出 552
21.4.3 浮点数输出 552
21.4.4 输出域 553
21.4.5 域的调整 555
21.4.6 操控符 555
21.5 文件流与字符串流 560
21.5.1 文件流 561
21.5.2 流的关闭 562
21.5.3 字符串流 563
21.6 缓冲 564
21.6.1 输出流和缓冲区 565
21.6.2 输入流和缓冲区 566
21.6.3 流和缓冲区 567
21.6.4 流缓冲区 567
21.7 现场 571
21.7.1 流回调 572
21.8 C输入/输出 573
21.9 忠告 575
21.10 练习 576
第22章 数值 578
22.1 引言 578
22.2 数值的限制 578
22.2.1 表示限制的宏 580
22.3 标准数学函数 580
22.4 向量算术 582
22.4.1 valarray的构造 582
22.4.2 valarray的下标和赋值 583
22.4.3 成员操作 584
22.4.4 非成员函数 586
22.4.5 切割 587
22.4.6 切割数组—slice_array 589
22.4.7 临时量、复制和循环 593
22.4.8 广义切割 595
22.4.9 屏蔽 596
22.4.10 间接数组—indirect_array 596
22.5 复数算术 597
22.6 通用数值算法 599
22.6.1 累积—accumulate 599
22.6.2 内积—inner_product 600
22.6.3 增量变化 600
22.7 随机数 602
22.8 忠告 603
22.9 练习 603
第四部分 用C++ 做设计
第23章 开发和设计 607
23.1 概述 607
23.2 引言 607
23.3 目的与手段 609
23.4 开发过程 611
23.4.1 开发循环 613
23.4.2 设计目标 615
23.4.3 设计步骤 616
23.4.4 试验和分析 623
23.4.5 测试 625
23.4.6 软件维护 625
23.4.7 效率 626
23.5 管理 626
23.5.1 重用 627
23.5.2 规模 628
23.5.3 个人 629
23.5.4 混成设计 630
23.6 带标注的参考文献 631
23.7 忠告 633
第24章 设计和编程 635
24.1 概述 635
24.2 设计和程序设计语言 635
24.2.1 忽视类 637
24.2.2 忽视继承 638
24.2.3 忽视静态类型检查 638
24.2.4 忽视程序设计 641
24.2.5 排他性地使用类层次结构 642
24.3 类 643
24.3.1 类表示什么 643
24.3.2 类层次结构 644
24.3.3 包容关系 648
24.3.4 包容和继承 649
24.3.5 使用关系 653
24.3.6 编入程序里的关系 654
24.3.7 类内的关系 656
24.4 组件 661
24.4.1 模板 663
24.4.2 界面和实现 665
24.4.3 肥大的界面 667
24.5 忠告 668
第25章 类的作用 670
25.1 类的种类 670
25.2 具体类型 672
25.2.1 具体类型的重用 672
25.3 抽象类型 674
25.4 结点 676
25.4.1 修改界面 677
25.5 动作 680
25.6 界面类 681
25.6.1 调整界面 683
25.7 句柄类 684
25.7.1 句柄上的操作 687
25.8 应用框架 688
25.9 忠告 689
25.10 练习 690
附录和索引
附录A 语法 695
附录B 兼容性 713
附录C 技术细节 724
附录D 现场 759
附录E 标准库的异常时安全性 815
索引 845

. C++ 是一个通用的程序设计语言，其核心应用领域是最广泛意义上的系统程序设计。此外，C++ 还被成功地用到许多无法称为系统程序设计的应用领域中。从最摩登的小型计算机到最大的超级计算机上，以及几乎所有操作系统上都有C++ 的实现。因此，本书描述的是C++ 语言本身，并不想试着去解释任何特殊的实现、程序设计环境或者库。
本书中给出的许多类的示例虽然都很有用，但也还是应该归到“玩具”一类。与在完整的精益求精的程序中做解释相比，这里所采用的解说风格能更清晰地呈现那些具有普遍意义的原理和极其有用的技术，在实际例子中它们很容易被细节所淹没。这里给出的大部分有用的类，如链接表、数组、字符串、矩阵、图形类、关联数组等，在广泛可用的各种商品的和非商品资源中，都有可用的“防弹”和/或“金盘”版本。那些“具有工业强度”的类和库中的许多东西，实际上不过是在这里可以找到的玩具版本的直接或间接后裔。
与本书的第1版相比，这一版更加强调本书的教学方面的作用。然而，这里的叙述仍然是针对有经验的程序员，并努力不去轻视他们的智慧和经验。有关设计问题的讨论有了很大的扩充，作为对读者在语言特征及其直接应用之外的要求的一种回应。技术细节和精确性也有所增强。特别是，这里的参考手册表现了在这个方向上多年的工作。我的目标是提供一本具有足够深度的书籍，使大部分程序员能在多次阅读中都有所收获。换句话说，这本书给出的是C++ 语言，它的基本原理，以及使用时所需要的关键性技术。欢迎欣赏！
致谢
除了在第1版序中致谢里所提到人们之外，我还要感谢Al Aho，Steve Buroff，Jim Coplien，Ted Goldstein，Tony Hansen，Lorraine Juhl，Peter Juhl, Brian Kernighan，Andrew Koenig，Bill Leggett，Warren Montgomery，Mike Mowbray，Rob Murray，Jonathan Shopiro，Mike Vilot和Peter Weinberger，他们对第2版的初稿提出了许多意见。许多人对C++从1985年到1991年的开发有很大影响，我只能提出其中几个：Andrew Koenig，Brian Kernighan，Doug McIlroy和Johathan Shopiro。还要感谢参考手册“外部评阅”的许多参与者，以及在X3J16的整个第一年里一直在其中受苦的人们。
Bjarne Stroustrup Murray Hill，新泽西
第1 版序
语言磨砺了我们思维的方式，也决定着我们思考的范围。
—B.L. Whorf
C++ 是一种通用的程序设计语言，其设计就是为了使认真的程序员工作得更愉快。除了一些小细节之外，C++ 是C程序设计语言的一个超集。C++ 提供了C所提供的各种功能，还为定义新类型提供了灵活而有效的功能。程序员可以通过定义新类型，使这些类型与应用中的概念紧密对应，从而把一个应用划分成许多容易管理的片段。这种程序构造技术通常被称为数据抽象。某些用户定义类型的对象包含着类型信息，这种对象就可以方便而安全地用在那种对象类型无法在编译时确定的环境中。使用这种类型的对象的程序通常被称为是基于对象的。如果用得好，这些技术可以产生出更短、更容易理解，而且也更容易管理的程序。
C++ 里的最关键概念是类。一个类就是一个用户定义类型。类提供了对数据的隐藏，数据的初始化保证，用户定义类型的隐式类型转换，动态类型识别，用户控制的存储管理，以及重载运算符的机制等。在类型检查和表述模块性方面，C++提供了比C好得多的功能。它还包含了许多并不直接与类相关的改进，包括符号常量、函数的在线替换、默认函数参数、重载函数名、自由存储管理运算符，以及引用类型等。C++ 保持了C高效处理硬件基本对象（位、字节、字、地址等）的能力。这就使用户定义类型能够在相当高的效率水平上实现。
C++ 及其标准库也是为了可移植性而设计的。当前的实现能够在大多数支持C的系统上运行。C的库也能用于C++ 程序，而且大部分支持C程序设计的工具也同样能用于C++。
本书的基本目标就是帮助认真的程序员学习这个语言，并将它用于那些非平凡的项目。书中提供了有关C++ 的完整描述，许多完整的例子，以及更多的程序片段。
致谢
如果没有许多朋友和同事持之以恒的使用、建议和建设性的批评，C++ 绝不会像它现在这样成熟。特别地，Tom Cargill，Jim Coplien，Stu Feldman，Sandy Fraser，Steve Johnson，Brian Kernighan，Bart Locanthi，Doug McIlroy，Dennis Rechie，Larry Rosler，Jerry Schwarz和Jon Shopiro对语言发展提供了重要的思想。Dave Presotto写出了流I/O库的当前实现。
此外，还有成百的人们对C++ 及其编译器的开发做出了贡献：他们给我提出改进的建议，描述他们所遇到的问题，告诉我编译中的错误等。我只能提出其中的很少几位：Gary Bishop，Abdrew Hume，Tom Karzes，Victor Milenkovic，Rob Murray，Leonie Rose，Brian Schmult和Gary Walker。
许多人在本书的撰写过程中为我提供了帮助，特别值得提出的是Jon Bentley，Laura Eaves，Brian Kernighan，Ted Kowalski，Steve Mahaney，Jon Shopiro，以及参加1985年7月26 ~ 27日俄亥俄州哥伦布贝尔实验室C++ 课程的人们。
Bjarne Stroustrup
Murray Hill, 新泽西
中文版序
本书是讲述标准C++的最完整和最新的著作，它拥有最多的读者，使用也最为广泛。按我目前的统计，本书已经被翻译成17种语言（参见http：//WWW．research.att.com／~bs/covers.html）。所以，这个译本所依据的原文，已经从成千上万的读者建议中获益匪浅。
现在，中国的程序员和事事学子能够更容易地读到本书，对此我尤感欣慰。我的中国同事，还有许许多多中国的程序员（通过电子邮件）早就向我建议有必要将本书译为中文。因为自己的母语也不是英语，我当然也认识到了这种必要性--何况，我还非常喜欢拿本书译本的总数作为C++得到广泛应用的活生生的例子。
自然了，所谓"仁者乐山，智者乐水"，有人会更喜欢英文原版，而另一些人则会感觉阅读翻译成母语的版本更能消除理解上的障碍。我认识许多程序员同时使用原版和译本，这样既能发挥母语的优势，又能用英语与全世界的程序员进行交流。
本书涵盖了标准C++、它的标准库和C++所支持的基本技术，如面向对象程序设计和通用型程序设计。其目的不仅仅是阐述语言的功能，还要提供如何行之有效地使用这些功能的信息，使程序员足以应付大多数开发项目。因此其中对设计的讨论非常重要。
1998年，ISO的C++标准（ISO/IEC 14882 Standond for the C++ Programming Language）得到了批准（各国标准委员会以22－0全票通过）。这是C++发展史上的一个里程碑，开创了C++工具和技术稳定发展的新纪元。
对我本人而言，其中关键在于，标准C++相对于以前的任何版本，更接近于我对C++的目标。标准C++及其标准库使我能够编写出比过去更好、更优雅、更高效的C++程序。
标准化的目的是为一种语言和一个库制定规范，使其能够服务于所有用户群体，而不至偏向于某个用户群、某个公司或某个国家。这是一个以保证质量和达成共识为目的的开放。公正的过程。
开放和民主的标准化过程存在～个潜在的问题：所谓"由委员会设计"。这在C++的标准化中基本上被避免了。原因之一在于，我担任了语言扩展工作组的主席。在此位置上，我负责评估所有关于主要语言扩展方面的建议，并就那些我本人、工作组和委员会都认为值得和可行的建议撰写最终版本。因此，委员会的主要活动是讨论提交上来的相对完整的设计，而不是自己来设计。与此类似，标准库的主要新增部分--"STL"（为容器、迭代器和算法提供了通用的、高效的、类型安全的和可扩展的框架），主要都源自一个人-Alexander stepanov的工作成果。
重要的是，C++标准不仅仅是一份文档。它已经在各种C＋十实现产品中得到了体现。所有主要的C++实现产品现在都实现了标准，只有极少的几个例外。为了帮助厂商更好地实现标准，现在至少有两个公司提供了标准C++的验证套件。因此，我现在写代码，只要合适，都会用到标准C++提供的和本书这一版中讲述的功能。
C++语言的改进和标准库的增加，使我自己编写代码的方式发生了显著变化。现在我的程序比原来更加简洁、更加高效。这直接得益于标准C++对抽象更好、更系统和更纯粹的支持。
对模板和异常等功能更好的支持，使对底层处理和更混乱的功能的需要大大降低了。而且，最近几年出现了许多新的设计和编程技术，这在本书的表达方法和实例中都有所反映。
C++现在可以作为高级语言来讲授了。也就是说，重点一开始就可以放在算法和容器上，而不用再在什么位呀，联合呀，C风格字符串，数组等等东西上纠缠不清了。自然，底层的概念（如数组、重要的指针应用和强制转换）最终还是要教要学的。但是，可以等到作为新手的C++程序员、读者或学生已经成熟，能够在实现这些功能的高级概念的大背景中看待它们的时候，再对这些功能进行阐释。
我想特别强调（怎么强调都不过分）的是，应该多使用静态类型安全的字符串和容器，而不要学那些使用大量宏、强制转换和数组的编程风格。在本书中，我能够根本就不用宏，并且只在很少的非用不可的情况下才使用强制转换。我认为C／C++形式的宏是一种严重的缺陷--现在因为有了模板、名字空间、在线函数和常量这些正确的语言功能，它很大程度上更是一种多余了。同样，在任何语言中，强制转换的大量使用都是设计不良的标志。宏和强制转换是错误的主要渊薮。不用它们也能工作，这一点大大提高了C++编程的安全性和优雅性。
标准C++改变了我们使用C++编程、设计程序以及教授C++编程的方式。这些变化不可能"毕其功于一役"。我鼓励你在标准C++、在本书中所用的设计和编程技术，以及自己的编程方式上好好下一番功夫。我想脱胎换骨是有可能的。但是别太死心眼了。奇迹是不存在的，在产品代码中使用仅仅一知半解的语言功能和技术是相当危险的。现在该开始探索，开始试验了--标准C++真正对你有所种益的地方，就在理解新概念和新技术的旅程中！
旅途愉快！
Bjarne Stroustrup