本书精华
·程序设计语言的基本概念
·Visual C++集成开发环境
·C++程序的构成
·变量、常量、运算符和表达式
·数据类型转换
·流程控制语句
·数组和字符串
·指针和引用
·结构、共用体和链表
·模块化编程：函数
·变量的类型、生存期、作用域和可见域
·面向对象程序设计
·面向对象编程三特征：封装、继承和多态
·虚函数、代码复用、友元
·泛型编程、模板、标准模板库STL
·高层I/O机制
·C++流类库
·异常与错误机制
·RTTI及转换类型符
·程序编码风格
·编译相关技巧

无

欢迎进入C++语言的世界，虽然说C++是在C语言的基础上发展而来的，但不同于C语言的面向结构编程机制，C++语言引入了面向对象编程和泛型编程机制，所以，完全可以把C++当成一门全新的语言来看，所以，在阅读本书时，并不要求读者具有C语言的基础。
　　C++语言是由贝尔实验室的Stroustrup于20世纪80年代初开发的，可以说C++是一门很年轻的语言，对C++的研究也一度十分活跃，各种新的特性被提出并尝试加入到这门语言中。为了C++的有序发展，ANSI/ISO C++国际标准第一版于1998年正式发布，2003年又发布了C++国际标准第二版，新标准在旧标准的基础上补充了很多内容。现今市面上大部分相关书籍，包括网络上一些学习资料还停留在1998年的旧式标准上，虽然现有编译器对1998标准和2003标准都提供了支持，但从效率和未来的发展来看，让初学者从开始就接触较新标准，并掌握C++的思维方式是非常重要的，本书是在这样的背景下写出的。
　　为了使读者能循序渐进地掌握C++的语法机制和编程思想，笔者精心编写了本书。本书根据读者一般的学习习惯，以循序渐进的方式，从最简单的“Hello,Word”程序写起，逐步深化、细化，对书中每个知识点和技术要点都给予了翔实的示例及代码分析，这些示例代码不仅一针见血地指明了技术要点的本质，而且短小精炼，方便复制和试验。
　　和其他书籍相比，本书有何特点
　　本书合理控制了知识点的深度和循序渐进的幅度，给读者展示出完整的C++语言全貌，书中所给示例代码条理清晰，简洁且直透本质，让读者迅速掌握技术要点的内涵。笔者从事多年项目开发，经验丰富，对技术要点进行了深入浅出的阐述。本书面向初、中级读者，以大量的示例进行示范和解说，其特点主要体现在以下几个方面。
　　q 本书的编排采用循序渐进的方式，适合初级、中级学者逐步掌握C++的语法规则和编程思想。
q 内容全面，兼顾了C++几乎所有的特性。
q 本书示例丰富，包含几百个代码，关键知识点都采用了示例代码以辅助读者理解。
q 所有示例都十分简洁，具有代表性，剪除旁枝末节，深入技术要点本质，每个范例集中说明一个概念或要点。
q 每个示例都配有详细的解释和说明，帮助读者理解代码。
q 对于学习中经常遇到的问题和需要注意的关键点予以特别注释。
q 大量使用了图例、表格等直观表达信息。
q 本书采用技术要点、详细介绍和示例运行等多种方式进行讲解，系统性强、可用性强，能给读者留下深刻印象。
本书包括的内容
本书共分为5篇，从基本的软硬件知识入手，让读者对程序有个整体的印象，随后介绍了C++语言的基本组成，分别从面向过程编程、面向对象编程和泛型编程3方面对C++的数据结构和程序组织进行了介绍，最后介绍了文件存储及其他一些编程规范等内容。
第一篇是基础知识介绍，涉及程序设计语言的基本概念，VC6开发环境的搭建，C++程序的构成，变量、常量、运算符和表达式，数据类型转换以及流程控制语句等内容。
第二篇介绍的是面向过程的C++程序开发，分别介绍了数组和字符串、指针和引用、结构、共用体和链表的使用，详细且视角独到地讲述了函数的使用，详细讨论了变量的类型、生存期、作用域和可见域，总结了函数编写时常出的问题，给出了函数编写的建议。
第三篇介绍的是面向对象（OOP）的C++程序开发，结合精炼的代码讲述了类的设计和使用、多态、虚函数、继承、代码复用和友元等内容，向读者展示了C++面向对象编程的全貌和独特魅力。
第四篇讨论的是泛型编程，这是由模板来实现的，使数据机构和算法的定义可以脱离具体类型的限制，据此，C++提供了标准模板库STL，模板和STL是本篇介绍的重点。
第五篇是文件存储和编程规范方面的内容，文件存储从基本的高层I/O机制讲起，而后介绍了C++流类库的使用、异常与错误机制、RTTI及转换类型符的应用、程序编码风格和C++程序编译相关的内容。
本书配套光盘内容
q 本书源代码 q 本书视频演示
q 本书电子教案（PPT） q 1200余页编程技术文档（免费赠送）
q 45个编程专题视频讲座（免费赠送）
适合阅读本书的读者
q C++的初学者
q 想从C语言跨越到C++语言的人员
q 了解C++但所学不全面的人员
q 想了解C++技术及最新进展的其他人员
q 高等院校理科学习C++课程的学生
q 使用C++语言进行毕业设计的学生
q 使用C++进行项目开发的人员
q 供熟悉其他语言的开发人员参考
关于作者
本书由李宽主笔编写，其他参与编写和资料整理的人员有高会东、王建超、邓薇、黄丽莉、吝晓宁、汪洋、白广元、蔡念光、陈辉、冯彬、刘长江、刘明、沙金、张士强、张洪福、多召英、贾旭、江宽、陈科、方成林、班晓娟、方中纯、刘兰军、郑雪峰等。

编　者

本书精华 ·程序设计语言的基本概念 ·Visual C++集成开发环境 ·C++程序的构成 ·变量、常量、运算符和表达式 ·数据类型转换 ·流程控制语句 ·数组和字符串 ·指针和引用 ·结构、共用体和链表 ·模块化编程：函数 ·变量的类型、生存期、作用域和可见域 ·面向对象程序设计 ·面向对象编程三特征：封装、继承和多态 ·虚函数、代码复用、友元 ·泛型编程、模板、标准模板库STL ·高层I/O机制 ·C++流类库 ·异常与错误机制 ·RTTI及转换类型符 ·程序编码风格 ·编译相关技巧

李　宽：暂无简介

写给未来的程序员
前言
第一篇　 C++基础
第1章　 C++概述 1
1.1　 了解计算机 1
1.1.1　 计算机硬件 1
1.1.2　 计算机软件 2
1.2　 程序设计语言 3
1.2.1　 机器语言 3
1.2.2　 汇编语言 4
1.2.3　 高级语言 4
1.2.4　 数据结构和算法 5
1.2.5　 面向过程的程序设计（POP） 5
1.2.6　 面向对象的程序设计（OOP） 6
1.3　 C++简介 6
1.3.1　 C++语言发展历程 6
1.3.2　 C++语言特点 7
1.3.3　 C++程序开发基本过程 7
1.4　 C++开发环境的搭建 8
1.4.1　 Visual C++ 6开发环境简介 8
1.4.2　 开发步骤 9
1.5　 第一个C++程序 10
1.6　 小结 11
第2章　 开始C++之旅 12
2.1　 C++程序的结构 12
2.1.1　 注释 12
2.1.2　 编译预处理与新旧标准 13
2.1.3　 主函数 13
2.1.4　 名称空间 14
2.1.5　 C++语素 15
2.2　 变量与基本类型 17
2.2.1　 变量 17
2.2.2　 整型 18
2.2.3　 浮点型 19
2.2.4　 基本字符型 19
2.2.5　 宽字符型 20
2.2.6　 布尔型 20
2.3　 常量 21
2.3.1　 整型常量和浮点型常量 21
2.3.2　 字符型常量 21
2.3.3　 字符串常量 23
2.3.4　 符号常量 24
2.3.5　 枚举（Enum）常量 25
2.4　 运算符与表达式 26
2.4.1　 算术运算 26
2.4.2　 逻辑运算 27
2.4.3　 短路表达式 28
2.4.4　 关系运算 28
2.4.5　 大有文章： 变量是否为“0” 29
2.4.6　 条件运算 30
2.4.7　 位运算 30
2.4.8　 赋值运算 32
2.4.9　 ++和-- 34
2.4.10　 逗号表达式 35
2.4.11　 sizeof运算符与sizeof表达式 35
2.4.12　 运算符的优先级和结合性 36
2.5　 类型转换 38
2.5.1　 赋值转换 38
2.5.2　 表达式中的转换 40
2.5.3　 强制类型转换 41
2.5.4　 函数调用、传递参数时的类型转换 42
2.6　 流程控制语句 42
2.6.1　 if...else...选择结构 42
2.6.2　 switch结构 44
2.6.3　 if...else...结构和switch结构的比较 47
2.6.4　 for循环结构 48
2.6.5　 for循环结构嵌套 49
2.6.6　 while循环结构 50
2.6.7　 do...while循环结构 51
2.6.8　 循环语句的效率 51
2.6.9　 流程转向控制语句之break 52
2.6.10　 流程转向控制语句之continue 52
2.6.11　 自由转向语句goto 53
2.6.12　 程序中止函数exit() 54
2.7　 小结 54
第二篇　　C++过程开发
第3章　 数组和C 风格字符串 55
3.1　 什么是数组 55
3.2　 一维数组 56
3.2.1　 一维数组的声明 56
3.2.2　 初始化一维数组 57
3.2.3　 一维数组应用举例 58
3.2.4　 数组操作注意事项 58
3.3　 C 风格字符串 59
3.3.1　 C 风格字符串的声明 59
3.3.2　 字符数组的cin和cout 60
3.3.3　 get( )函数和getline( )函数 60
3.3.4　 cin与get( )/getline( )函数的搭配问题 62
3.3.5　 访问C风格字符串中的某个元素 62
3.3.6　 C风格字符串处理函数 63
3.4　 多维数组 65
3.4.1　 声明一个多维数组 65
3.4.2　 初始化多维数组 65
3.4.3　 多维数组应用举例 66
3.4.4　 多维数组在内存中是如何排列元素的 67
3.5　 小结 68
第4章　 指针和引用 69
4.1　 指针的定义与使用 69
4.1.1　 声明一个指针变量 69
4.1.2　 初始化指针变量 72
4.1.3　 指向指针的指针 72
4.1.4　 指针赋值 73
4.2　 指针的运算 74
4.2.1　 指针与整数的加减 74
4.2.2　 同类型指针间的比较 75
4.2.3　 同类型指针相减 75
4.3　 动态内存分配 76
4.3.1　 使用new动态分配内存 76
4.3.2　 使用delete动态释放动态申请的内存 76
4.3.3　 使用new申请动态数组 77
4.3.4　 不要使用或释放已经释放的内存块 78
4.3.5　 使用malloc和free动态申请内存 78
4.3.6　 动态内存申请并不一定成功 80
4.4　 指针和const 80
4.4.1　 禁止改写指针（常量指针或常指针） 80
4.4.2　 禁止改写间接引用 81
4.4.3　 既禁止改写指针，又禁止改写间接引用 81
4.5　 指针与数组 81
4.5.1　 数组名指针 81
4.5.2　 数组元素的指针形式 83
4.5.3　 指向数组的指针 83
4.5.4　 指针数组 85
4.6　 引用 87
4.6.1　 引用的声明 88
4.6.2　 引用的特点 88
4.6.3　 引用的使用限制 89
4.6.4　 其他要说明的问题 89
4.7　 小结 90
第5章　 结构、共用体和链表 91
5.1　 结构 91
5.1.1　 如何定义一个结构 91
5.1.2　 结构变量的声明和使用 92
5.1.3　 结构变量的初始化 93
5.1.4　 结构变量间是否可以相互赋值 94
5.1.5　 结构体变量的sizeof 95
5.2　 共用体 96
5.2.1　 共用体的定义 97
5.2.2　 共用体和结构的不同 97
5.2.3　 共用体变量的声明和初始化 98
5.2.4　 共用体使用举例 99
5.2.5　 共用体的sizeof 100
5.3　 结构数组和共用体数组 101
5.3.1　 结构数组的声明和初始化 101
5.3.2　 共用体数组的声明和初始化 102
5.4　 指向结构的指针 103
5.4.1　 声明一个结构指针 103
5.4.2　 结构指针的初始化 103
5.4.3　 使用指针访问结构成员 105
5.5　 链表 106
5.5.1　 链表的结构 106
5.5.2　 创建链表 107
5.5.3　 链表与数组的区别 107
5.5.4　 链表的遍历和查找 108
5.5.5　 链表的插入和删除 109
5.6　 小结 113
第6章　 用函数合理组织程序 114
6.1　 模块化带来的好处 114
6.1.1　 函数的调用过程 114
6.1.2　 抽象和封装 115
6.1.3　 实现一个函数 115
6.2　 函数定义 116
6.2.1　 函数头 116
6.2.2　 函数体 117
6.2.3　 函数定义补充说明 117
6.3　 函数声明 119
6.3.1　 为什么要进行函数声明 119
6.3.2　 如何声明一个函数 120
6.3.3　 分割程序文件 120
6.4　 函数调用 122
6.4.1　 形参和实参 122
6.4.2　 参数类型转换 123
6.4.3　 值传递 123
6.4.4　 指针传递 124
6.4.5　 引用传递 125
6.4.6　 对3种传递的补充 126
6.4.7　 缺省参数调用 128
6.4.8　 inline函数 129
6.5　 递归 131
6.6　 函数的重载 132
6.6.1　 何时使用函数重载 133
6.6.2　 如何实现函数重载 133
6.6.3　 陷阱：隐式转换导致重载函数出现二义性 134
6.7　 C++如何使用内存 134
6.7.1　 自动存储（栈存储） 135
6.7.2　 静态存储（编译器预分配） 137
6.8　 作用域与可见域 141
6.8.1　 作用域 142
6.8.2　 可见域 142
6.8.3　 函数的作用域和可见域 145
6.9　 小结 145
第7章　 关于函数的高级专题 147
7.1　 内存使用错误剖析 147
7.1.1　 内存泄露 147
7.1.2　 野指针 148
7.1.3　 试图修改常量 149
7.1.4　 用错sizeof 149
7.1.5　 内存越界访问 150
7.1.6　 变量的初始化 150
7.2　 重申：函数参数传递和返回机制 150
7.2.1　 参数传递时的“副本” 151
7.2.2　 函数返回时的“副本” 152
7.3　 函数与指针 154
7.3.1　 指向函数的指针 154
7.3.2　 typedef 155
7.3.3　 通过函数指针将函数作为另一个函数的参数 157
7.3.4　 函数指针数组 158
7.3.5　 返回函数指针的函数 159
7.3.6　 带参主函数 160
7.4　 函数与数组 161
7.4.1　 数组名作函数参数 161
7.4.2　 通过指针得到多于1个的回传值 163
7.5　 函数与结构体、共用体及类对象 164
7.5.1　 3种参数调用 164
7.5.2　 3种返回机制 166
7.6　 函数编写的建议 166
7.6.1　 合理使用const 166
7.6.2　 检查输入参数的有效性 167
7.6.3　 函数返回类型的判断 167
7.7　 小结 167
第三篇　 面向对象的C++
第8章　 面向对象技术基础 169
8.1　 面向对象基本概念 169
8.1.1　 类的概念 169
8.1.2　 类是分层的 170
8.1.3　 类和对象的关系 170
8.2　 C++类的定义 171
8.2.1　 类定义的基本形式 171
8.2.2　 类定义示例 172
8.2.3　 class和struct 173
8.3　 C++类的实现 173
8.3.1　 在类定义时定义成员函数 173
8.3.2　 在类定义的外部定义成员函数 174
8.4　 C++类的使用 175
8.4.1　 声明一个对象 175
8.4.2　 对象的作用域、可见域和生存期 176
8.5　 对象的创建和撤销 176
8.5.1　 构造函数的作用 177
8.5.2　 构造函数可以有参数 177
8.5.3　 构造函数支持重载 178
8.5.4　 构造函数允许按参数缺省方式调用 179
8.5.5　 初始化表达式 180
8.5.6　 析构函数 181
8.5.7　 显式调用析构函数 183
8.6　 复制构造函数 183
8.6.1　 复制构造函数调用机制 184
8.6.2　 缺省复制构造函数带来的问题 185
8.6.3　 解决方案—显式定义复制构造函数 187
8.6.4　 关于构造函数和复制构造函数 188
8.7　 特殊数据成员 189
8.7.1　 const数据成员 189
8.7.2　 引用成员 191
8.7.3　 类对象成员 193
8.7.4　 特别说明 197
8.7.5　 static数据成员 197
8.8　 特殊函数成员 199
8.8.1　 静态成员函数 199
8.8.2　 const与成员函数 201
8.9　 对象的组织 202
8.9.1　 const对象 202
8.9.2　 指向对象的指针 203
8.9.3　 对象的大小 204
8.9.4　 this指针 206
8.9.5　 对象数组 207
8.9.6　 对象链表 208
8.10　 为对象动态分配内存 208
8.10.1　 使用new和delete为单个对象分配/释放动态内存 208
8.10.2　 使用new和delete为对象数组分配/释放动态空间 209
8.10.3　 malloc和free能否为对象动态申请内存 210
8.11　 小结 211
第9章　 关于对象的高级专题 212
9.1　 类作用域 212
9.2　 类定义的作用域与可见域 213
9.3　 对象的生存期、作用域和可见域 216
9.3.1　 先定义，后实例化 216
9.3.2　 对象内存释放与堆内存 217
9.4　 友元 217
9.4.1　 友元之非成员函数 217
9.4.2　 友元之成员函数 219
9.4.3　 友元函数的重载 220
9.4.4　 友元类 220
9.4.5　 友元是否破坏了封装性 222
9.5　 运算符重载 222
9.5.1　 运算符重载规则 223
9.5.2　 以成员函数形式重载运算符 223
9.5.3　 以友元函数形式重载运算符 227
9.5.4　 友员函数形式和成员函数形式的比较 229
9.5.5　 对运算符重载的补充说明 231
9.6　 运算符重载范例 231
9.6.1　 赋值运算符 231
9.6.2　 函数调用运算符 234
9.6.3　 下标运算符 235
9.7　 类型转换 237
9.7.1　 由其他类型向定义类的转换 237
9.7.2　 由自定义类型转换为其他类型 239
9.7.3　 隐式转换带来的二义性 241
9.8　 重载函数选择规则 241
9.8.1　 重载解析 242
9.8.2　 什么是完全匹配 242
9.9　 小结 243
第10章　 继承 244
10.1　 什么是继承 244
10.1.1　 简单示例 244
10.1.2　 继承的层次性 246
10.2　 派生类 246
10.2.1　 public派生与private派生 246
10.2.2　 protected成员与protected派生 247
10.3　 多基派生 248
10.3.1　 多基派生的声明和定义 248
10.3.2　 二义性问题 248
10.3.3　 解决方案 250
10.4　 虚基类 250
10.4.1　 共同基类带来的二义性 250
10.4.2　 解决方案 251
10.4.3　 虚基派生二义性与多基派生二义性不同 253
10.5　 派生类的构造函数和析构函数 253
10.5.1　 派生类的构造函数 253
10.5.2　 派生类的析构函数 255
10.5.3　 多基派生类的构造函数和析构函数 256
10.5.4　 虚基派生的构造函数和析构函数 256
10.6　 分清继承还是组合 259
10.6.1　 继承 259
10.6.2　 组合 260
10.7　 基类与派生类对象间的相互转换 261
10.7.1　 类型适应 261
10.7.2　 多基继承时的情况 263
10.7.3　 公共基类 264
10.7.4　 虚基类的情况 266
10.8　 小结 266
第11章　 多态 268
11.1　 多态与虚函数 268
11.1.1　 静态联编 268
11.1.2　 动态联编 268
11.1.3　 为什么需要虚函数 268
11.1.4　 虚函数的声明和定义 271
11.2　 虚函数的访问 271
11.2.1　 对象名访问 272
11.2.2　 指针访问 272
11.2.3　 引用访问 273
11.2.4　 类内访问 274
11.2.5　 在构造函数或析构函数中访问 275
11.3　 纯虚函数与抽象类 276
11.3.1　 纯虚函数的声明和定义 276
11.3.2　 抽象类 277
11.3.3　 另一种抽象类：类中只定义了protected型的构造函数 280
11.3.4　 延伸：构造函数能否为private型 281
11.3.5　 虚析构函数 282
11.4　 虚函数引入的二义性 285
11.4.1　 多基派生 285
11.4.2　 共同基类和虚继承 287
11.5　 重载、覆盖与隐藏 289
11.5.1　 重载 289
11.5.2　 覆盖 289
11.5.3　 隐藏 290
11.6　 小结 291
第四篇　 泛 型 编 程
第12章　 模板 293
12.1　 为什么要定义模板 293
12.1.1　 类型参数化 293
12.1.2　 模板的定义 295
12.2　 函数模板 296
12.2.1　 函数模板的使用 296
12.2.2　 隐式实例化 296
12.2.3　 显式实例化 297
12.2.4　 特化 298
12.2.5　 重载 299
12.2.6　 优先级与执行顺序 300
12.3　 类模板 302
12.3.1　 定义类模板 302
12.3.2　 隐式实例化 304
12.3.3　 显式实例化 304
12.3.4　 显式特化 304
12.3.5　 部分特化 305
12.3.6　 重载和优先级 306
12.4　 模板的嵌套 307
12.4.1　 函数成员模板 307
12.4.2　 对象成员模板 308
12.5　 模板参数 309
12.6　 小结 310
第13章　 标准模板库（STL） 311
13.1　 理解STL 311
13.1.1　 容器 311
13.1.2　 适配器 311
13.1.3　 迭代器 312
13.1.4　 算法 312
13.2　 使用序列式容器 312
13.2.1　 序列式容器的创建和元素的访问 312
13.2.2　 所有容器都支持的特征 314
13.2.3　 序列式容器中元素的插入和删除 314
13.2.4　 vector容器 319
13.2.5　 deque容器 319
13.2.6　 list容器 320
13.3　 使用关联式容器 320
13.3.1　 set容器 320
13.3.2　 multiset容器 321
13.3.3　 map容器 322
13.3.4　 multimap容器 323
13.4　 关联式容器支持的成员函数操作 324
13.4.1　 元素的插入 324
13.4.2　 元素的删除 327
13.4.3　 元素的查找与访问 329
13.5　 迭代器 330
13.5.1　 理解迭代器本质 330
13.5.2　 迭代器类型 331
13.5.3　 为什么要定义这么多迭代器 332
13.5.4　 容器中定义的迭代器类型与5种类型的对应 333
13.5.5　 流迭代器 333
13.5.6　 迭代器失效 335
13.6　 泛型算法 335
13.6.1　 什么是函数对象 335
13.6.2　 算法分类 336
13.7　 适配器 340
13.7.1　 容器适配器 341
13.7.2　 迭代器适配器 342
13.7.3　 函数适配器 344
13.8　 小结 345
第五篇　 输入输出处理和编程规范
第14章　 输入输出和文件 347
14.1　 输入输出概述 347
14.1.1　 什么是文件 347
14.1.2　 流 348
14.1.3　 缓冲区 349
14.1.4　 重定向 349
14.1.5　 3种输入输出机制 350
14.2　 高层I/O 351
14.2.1　 标准输出函数printf 351
14.2.2　 标准输入函数scanf 354
14.2.3　 扫描集 357
14.2.4　 sprintf和sscanf函数 358
14.2.5　 fprintf和fscanf函数 359
14.2.6　 文件访问机制 359
14.3　 流类库 363
14.3.1　 流类库更安全、更高效 363
14.3.2　 流类库层次 363
14.4　 输出流 367
14.4.1　 操作符<< 367
14.4.2　 其他ostream方法 368
14.4.3　 格式状态字 369
14.4.4　 格式控制值的默认值 371
14.4.5　 flag( )函数读取和设定格式状态字 371
14.4.6　 使用setf函数和unsetf函数设定格式关键字 373
14.4.7　 设置域宽 375
14.4.8　 填充字符 376
14.4.9　 浮点数输出和显示精度 377
14.4.10　 控制符 378
14.5　 输入流 380
14.5.1　 >>操作符 380
14.5.2　 输入流与格式状态字 381
14.5.3　 输入流与域宽 383
14.5.4　 使用get函数读取单个字符 383
14.5.5　 使用get和getline函数读取C风格字符串 386
14.5.6　 其他istream方法 387
14.6　 流状态 389
14.6.1　 什么是流状态 389
14.6.2　 读取流状态 389
14.6.3　 管理流状态 391
14.7　 重载>>和<< 392
14.7.1　 插入符的重载 392
14.7.2　 抽取符的重载 394
14.8　 文件操作 395
14.8.1　 文件操作基本过程 395
14.8.2　 文件的打开 395
14.8.3　 取消文件和流的关联 397
14.8.4　 文件的读写 398
14.8.5　 文本文件的读写 399
14.8.6　 二进制文件的读写 399
14.8.7　 文件定位指针和随机读取 400
14.9　 字符串流 402
14.9.1　 strstream类族 402
14.9.2　 sstream类族 405
14.10　 小结 408
第15章　 名称空间 409
15.1　 什么是名称空间 409
15.1.1　 名称空间范例 409
15.1.2　 定义名称空间 410
15.2　 实体的作用域与可见域 411
15.2.1　 实体可见域 411
15.2.2　 可见域的扩展 412
15.2.3　 using声明机制 413
15.2.4　 using声明带来的多重声明问题（二义性） 415
15.2.5　 空间内的“屏蔽” 415
15.2.6　 先声明，后使用 416
15.3　 名称空间的作用域与可见性 417
15.3.1　 名称空间的定义策略 417
15.3.2　 推荐用法 419
15.3.3　 名称空间嵌套 421
15.3.4　 using编译指令 422
15.3.5　 未命名的名称空间 423
15.4　 对名称空间的思考 423
15.5　 小结 424
第16章　 异常和错误 425
16.1　 编码时的防错 425
16.1.1　 调用abort函数或exit函数 425
16.1.2　 返回错误标志 426
16.2　 异常机制 427
16.2.1　 关键字throw 428
16.2.2　 异常处理程序 429
16.2.3　 自定义异常对象 432
16.2.4　 有继承关系的类异常 433
16.2.5　 terminate函数和set_terminate函数 434
16.2.6　 unexpected函数与set_unexpected函数 435
16.2.7　 标准异常 436
16.2.8　 对unexpected函数的补充 438
16.3　 异常发生时的内存管理 440
16.3.1　 堆栈解退 440
16.3.2　 异常处理机制和函数的不同 441
16.3.3　 构造函数中抛出异常 442
16.3.4　 内存泄露 443
16.3.5　 析构函数中可否抛出异常 444
16.4　 auto_ptr类 445
16.4.1　 使用auto_ptr类 445
16.4.2　 关于auto_ptr的若干问题 446
16.5　 小结 447
第17章　 RTTI和类型转换操作符 448
17.1　 RTTI机制 448
17.1.1　 dynamic_cast操作符 448
17.1.2　 typeinfo类和typeid操作符 450
17.1.3　 补充说明 451
17.2　 类型转换操作符 451
17.2.1　 const_cast操作符 451
17.2.2　 static_cast操作符 452
17.2.3　 reinterpret_cast操作符 452
17.3　 小结 453
第18章　 string类 454
18.1　 为什么要使用string类 454
18.2　 声明一个字符串 454
18.3　 字符串的输入输出 455
18.4　 string类功能 457
18.4.1　 string字符串和C风格字符串的转换 457
18.4.2　 赋值和清空 457
18.4.3　 元素删除 457
18.4.4　 元素追加与相加 458
18.4.5　 元素插入 458
18.4.6　 大小和容量 459
18.4.7　 元素存取 459
18.4.8　 字符串比较 459
18.4.9　 提取子串 459
18.4.10　 搜索与查找 459
18.5　 小结 460
第19章　 编码风格 461
19.1　 程序的排版 461
19.1.1　 注释 461
19.1.2　 空行的用法 462
19.1.3　 代码行 462
19.1.4　 空格 462
19.1.5　 缩进与对齐 463
19.1.6　 &和*的位置 463
19.2　 命名规则 463
19.2.1　 Windows风格和Unix风格 463
19.2.2　 如何对程序实体命名 463
19.3　 项目文件的组织 464
19.3.1　 模块划分 464
19.3.2　 头文件 464
19.3.3　 定义文件 465
19.3.4　 目录结构 465
19.4　 小结 465
第20章　 程序编译 466
20.1　 程序的编译流程 466
20.2　 预处理 467
20.2.1　 头文件包含 467
20.2.2　 宏 468
20.2.3　 条件编译 469
20.2.4　 #ifdef、#ifndef与重复包含 470
20.2.5　 使用const代替#define定义常量 471
20.2.6　 inline与#define的比较 471
20.3　 VC6调试入门 472
20.3.1　 断点的设置与去除 472
20.3.2　 条件断点 473
20.3.3　 数据断点 473
20.3.4　 消息断点 473
20.3.5　 观察视图Watch 473
20.3.6　 内存视图Memory 474
20.3.7　 变量视图Variables 474
20.3.8　 寄存器视图Registers 474
20.3.9　 调用堆栈视图Call　 Stack 474
20.3.10　 反汇编视图　 Disassembly 474
20.3.11　 进程控制 475
20.4　 其他调试手段 475
20.4.1　 Debug模式和Release模式 475
20.4.2　 assert宏 475
20.4.3　 偷懒的办法：输出字符串 475
20.5　 小结 476