标准C++程序设计教程PDF电子书下载

序言 1

第1单元 C++函数、控制结构与数据类型 3

第1章 了解C++ 3

1.1 计算机语言 4

1.2 C语言和C++语言简史 6

1.3 从C语言到C++语言的转换 8

1.4 C++的基本概念 9

1.5 C++语言及其增强类型 11

1.6 C++环境 12

1.7 C语言与C++语言的未来 13

1.8 C++基本知识点小结 13

第2章 编写简单的C++程序 15

2.1 主函数main() 15

实例2-1 一个最小的C++程序 15

2.2 简单的C++程序 16

实例2-2 自己编写的第一个C++程序 16

2.2.1 #include指令 17

2.2.2 空白 17

2.2.3 main()函数的声明 17

2.2.4 main()函数的作用范围 18

2.2.5 源程序中的注释 18

2.2.6 控制台输出 18

2.2.7 return语句 18

2.2.8 程序的结束 18

2.3 标识符 18

2.4 关键字 19

2.5 标准输出流 19

2.6 变量 20

2.6.1 布尔型 21

实例2-3 应用布尔型变量 21

2.6.2 字符型 21

实例2-4 字符型变量的应用 21

2.6.3 wchar_t型 22

实例2-5 wchar_t型变量的使用 22

2.6.4 整型 23

实例2-6 引用int数据类型 24

2.6.5 浮点类型 24

实例2-7 声明和引用浮点型变量 25

2.7 常量 25

2.7.1 字符型常量 25

2.7.2 转义字符 26

2.7.3 整型常量 26

2.7.4 浮点型常量 27

2.7.5 地址常量 27

2.7.6 字符串常量 27

实例2-8 字符串常量的合并 28

2.8 表达式 28

2.9 赋值语句 29

实例2-9 应用赋值语句和表达式 29

2.10 用逗号分隔开的声明语句 30

2.11 表达式中的运算符 31

2.11.1 算术运算符 31

实例2-10 表达式赋值 31

2.11.2 逻辑运算符 32

2.11.3 位逻辑运算符 33

2.11.4 位移运算符 34

2.11.5 关系运算符 34

2.11.6 自增和自减运算符 36

实例2-11 自增和自减运算符的位置 36

2.11.7 赋值运算符 37

实例2-12 赋值运算符 38

2.11.8 复合赋值运算符 39

实例2-13 复合赋值运算符应用 39

2.11.9 条件运算符 40

实例2-14 计算罚款数目 40

2.11.10 逗号运算符 41

实例2-15 逗号运算符应用 41

2.12 优先级和计算顺序 42

2.12.1 结合律 43

2.12.2 优先级 43

2.13 表达式不参加运算的情况 44

2.14 初始化 44

实例2-16 不同变量的初始化 44

2.15 类型转换 45

实例2-17 几种类型转换 46

2.16 控制台输入与输出 47

2.16.1 标准输出流 47

实例2-18 利用std::cout优化代码 47

2.16.2 格式化输出 48

实例2-19 用三种进制形式显示整数 48

2.16.3 标准错误流 49

2.16.4 标准输入流 49

实例2-20 使用cin从键盘读入一个整数 49

实例2-21 使用std::cin设备从键盘把字符串读入到字符串数组中 50

第3章 C++函数 51

3.1 函数简介 51

3.2 函数原型 52

3.2.1 无标识符的参数类型 52

3.2.2 函数原型实例 53

3.2.3 void型函数 53

3.2.4 无参数的函数 53

3.2.5 参数个数可变的函数 53

3.2.6 既没有返回值也不带参数的函数 54

3.2.7 标准库函数的原型 54

3.2.8 不需要原型的函数 54

3.3 函数的定义与调用 54

实例3-1 定义一个函数 54

3.4 函数的返回 55

实例3-2 return语句可在函数体内的任何位置 56

3.5 函数的返回值 57

实例3-3 计算宽度 57

3.6 参数的传递和使用 58

实例3-4 计算宽度——改进版本 58

3.6.1 标识符的作用域 59

3.6.2 通过函数调用来初始化 60

3.6.3 初始化执行的顺序 60

3.6.4 传递多个参数 60

实例3-5 计算砖块的体积 60

3.6.5 用做实参的函数调用 61

3.6.6 值传递 61

3.6.7 实参和返回值的类型转换 61

3.7 无名的函数形参 62

3.8 函数的默认参数 62

实例3-6 默认参数的用法 62

3.9 内联函数 63

实例3-7 指定为内联函数 63

3.10 递归 64

3.11 函数重载 64

3.11.1 为完成不同的操作而重载 64

实例3-8 复制字符串 65

3.11.2 为不同的格式而重载 66

实例3-9 显示时间 66

3.12 安全连接 67

3.13 连接说明 67

实例3-10 使用C的连接约定 68

第4章 C++控制结构 71

4.1 语句块 71

4.1.1 嵌套深度 71

4.1.2 缩进风格 71

4.2 条件语句 72

4.2.1 if语句 72

实例4-1 检验条件是否为零 72

实例4-2 检验变量是否为零 73

实例4-3 条件为真时执行 74

4.2.2 if…else语句 75

实例4-4 有条件地执行程序块 75

4.2.3 else...if语句 75

实例4-5 屏幕菜单程序 75

4.2.4 switch...case语句 77

实例4-6 检验整型变量的取值 77

4.2.5 在if语句的条件表达式里声明变量 78

4.3 循环语句 79

4.3.1 while语句 79

实例4-7 菜单选择与退出 79

4.3.2 do...while语句 81

实例4-8 猜谜游戏 81

4.3.3 for语句 82

实例4-9 限次循环显示 82

实例4-10 遍历数组中的每一个元素 83

4.3.4 在for语句的条件表达式内声明变量 84

4.4 循环控制 84

4.4.1 break语句 84

实例4-11 终止并跳出循环 84

4.4.2 continue语句 85

实例4-12 中断但不跳出循环 85

4.5 跳转 86

实例4-13 跳转到任意可执行语句 86

4.5.1 goto语句的错误用法 87

4.5.2 C++的goto和C的goto 88

4.5.3 goto语句错误的改正 88

实例4-14 优化的跳转程序之一 88

实例4-15 优化的跳转程序之二 88

4.5.4 是否可以使用goto语句 89

第5章 C++数据类型 91

5.1 作用域 91

5.1.1 全局作用域 91

实例5-1 具有全局作用域的外部变量 91

5.1.2 局部作用域 92

实例5-2 具有局部作用域的变量 93

实例5-3 作用域的屏蔽 93

5.1.3 全局作用域解析符 94

实例5-4 使用全局作用域解析符 94

5.1.4 文件作用域 95

实例5-5 static存储类型修饰符 95

5.1.5 作用域和生存周期 96

实例5-6 变量的生存周期 96

5.2 存储类型 97

5.2.1 自动存储类型 98

5.2.2 静态存储类型 98

实例5-7 静态局部变量 98

5.2.3 外部存储类型 99

实例5-8 使用外部变量 99

5.2.4 寄存器存储类型 100

实例5-9 使用寄存器变量 100

5.3 初始化的默认值 101

5.4 类型修饰符 101

5.4.1 const类型修饰符 101

实例5-10 使用const型变量作为循环的上限 102

5.4.2 volatile类型修饰符 102

实例5-11 声明volatile型变量 102

5.5 用户定义的数据类型 103

5.5.1 结构的声明 103

5.5.2 结构变量的定义 103

5.5.3 对结构成员的引用 104

实例5-12 结构的声明与使用 104

5.5.4 结构的初始化 105

实例5-13 初始化结构变量 105

5.5.5 结构的嵌套 105

实例5-14 声明两个结构 105

5.5.6 函数传递结构和从函数返回结构 106

实例5-15 传递和返回结构 107

5.6 联合数据类型 108

实例5-16 使用联合 108

5.6.1 联合的初始化 109

实例5-17 初始化一个包含结构的联合 109

5.6.2 匿名联合 110

实例5-18 使用匿名联合 110

5.6.3 枚举常量 111

实例5-19 在switch语句中使用枚举类型 111

5.7 数组 112

5.7.1 数组的声明 112

5.7.2 利用下标访问数组元素 113

5.7.3 数组的初始化 113

实例5-20 一个简单的7元素整型数组 113

5.7.4 结构数组 114

实例5-21 一个简单的结构数组 114

5.7.5 多维数组 115

实例5-22 二维数组——税收数据表 115

5.7.6 字符型数组 116

实例5-23 初始化字符型数组 117

第6章 指针、地址与引用 119

6.1 指针和地址 119

6.1.1 指向内部数据类型的指针 120

实例6-1 指向C++内部数据类型的指针 120

6.1.2 指针的算术运算 121

实例6-2 指针运算 121

实例6-3 利用指针变量对数组进行遍历 123

6.1.3 指针和数组 123

实例6-4 一种新的数组地址表示法 124

实例6-5 指针和数组的几种常见用法 125

6.1.4 结构指针 126

实例6-6 利用结构指针遍历结构数组 126

6.1.5 用做函数参数的指针 127

实例6-7 指针作为参数使用 128

实例6-8 指向多维数组的指针参数 128

6.1.6 以地址作为函数的返回值 130

实例6-9 返回地址的函数 130

实例6-10 利用指针遍历数组 131

6.1.7 函数指针 132

实例6-11 函数指针的用法 132

实例6-12 菜单管理器 133

6.1.8 指针的指针 135

实例6-13 检索指针的指向 135

6.1.9 指向指针数组的指针 136

实例6-14 字符串表 136

6.1.10 指向const型变量的指针 137

实例6-15 标准C的std::strcpy()函数实现 138

6.1.11 const型指针变量 139

实例6-16 使用const型指针 139

6.1.12 void型指针 140

实例6-17 标准C在<cstdlib>头文件中声明的内存管理函数 140

6.2 sizeof运算符 142

实例6-18 动态地计算数组元素的个数 143

6.3 C风格的强制类型转换与typedef 143

实例6-19 改变记录计数器的数值类型 144

6.4 命令行参数 145

实例6-20 命令行参数的用法 146

6.5 程序的内存结构 146

6.5.1 堆 147

6.5.2 new和delete运算符 147

实例6-21 new和delete运算符的用法 147

6.5.3 为固定大小的数组分配内存 148

实例6-22 用new和delete为数组分配和释放内存 148

6.5.4 为动态数组分配内存 149

实例6-23 用new运算符为可变大小的数组分配内存 149

6.5.5 堆耗尽时的处理 150

6.5.6 栈 150

6.6 递归 151

6.6.1 一个简单递归的例子 151

实例6-24 逆序显示姓名 151

6.6.2 一个使用了递归的计算器程序 152

实例6-25 一个计算数字表达式的计算器程序 152

6.7 引用型变量 156

6.7.1 引用是一个别名 156

实例6-26 引用型变量的用法 157

实例6-27 比较实际变量地址和引用地址 157

6.7.2 引用的初始化 158

6.7.3 利用引用来简化复杂的表示法 158

实例6-28 利用引用来简化复杂的表示法 158

6.7.4 作为函数形参的引用 160

实例6-29 以引用代替复制 160

6.7.5 以引用方式调用 161

实例6-30 把引用作为参数传递 161

6.7.6 eonst型引用形参 163

6.7.7 以引用作为返回值 163

实例6-31 引用函数返回值 163

6.7.8 以const型引用作为返回值 164

6.7.9 返回指向自变量的引用 164

6.7.10 指针和引用 165

第1单元练习 167

第2单元 C++库函数与函数模板 179

第7章 C++库函数和宏 179

7.1 <cassert> 180

实例7-1 assert宏的用法 180

7.2 <cctype> 181

7.3 <cerrno> 182

实例7-2 errno变量的用法 182

7.4 <cmath> 183

7.5 <csetjmp> 184

实例7-3 setjmp()和longjmp()函数的用法 184

7.6 <cstdarg> 186

实例7-4 处理参数个数可变的函数 186

7.7 <cstdio> 187

7.8 <cstdlib> 187

7.8.1 数字函数 187

7.8.2 内存管理函数 188

7.8.3 系统函数 188

7.8.4 随机数发生器函数 189

实例7-5 改进的猜谜游戏 189

7.9 <cstring> 190

实例7-6 比较和复制字符串 190

7.10 <ctime> 192

实例7-7 显示当前的格林威治标准时间 193

第8章 C+4程序的预处理 195

8.1 预处理指令 195

8.2 文件的包含与#include指令 196

8.3 宏 197

8.3.1 #define指令 197

8.3.2 带参数的#define指令 198

实例8-1 计算工资 199

实例8-2 改进后的计算工资程序 201

8.3.3 格式和对齐 203

8.3.4 #运算符 203

实例8-3 字符串化运算符的用法 204

8.3.5 ##运算符 204

实例8-4 符号连接运算符的用法 204

实例8-5 符号连接运算符的高级用法 205

8.3.6 #undef指令 205

8.4 条件编译指令 206

8.4.1 #if指令 206

8.4.2 #endif指令 206

实例8-6 #if和#endif的用法 206

8.4.3 #ifdefined指令 206

实例8-7 检测宏是否被定义 207

8.4.4 #ifdef和#ifndef指令 207

8.4.5 #else指令 207

实例8-8 #else预处理指令的用法 207

8.4.6 #elif指令 208

实例8-9 #elif预处理指令的用法 208

8.4.7 #error指令 208

实例8-10 检测宏表示的值 209

8.5 其他标准指令 209

8.5.1 #line指令 210

8.5.2 #pragma指令 210

第9章 C++结构与类 211

9.1 C++的类 211

9.2 数据类型的属性 211

9.2.1 数据描述 212

9.2.2 实现 212

9.2.3 性质 212

9.2.4 接口 212

9.3 用户定义数据类型 212

9.3.1 抽象 212

9.3.2 对象是什么 212

9.3.3 数据抽象和面向过程编程 213

实例9-1 显示日期 213

9.3.4 数据抽象和封装 214

9.4 带有函数的结构体 215

9.4.1 向结构体添加函数 215

实例9-2 显示一个人的生日 215

9.4.2 同一结构的多个实例 216

实例9-3 显示几个人的生日 216

9.4.3 具有相同函数名的不同结构 217

实例9-4 显示日期和时间 217

9.5 访问控制符 219

9.6 面向过程的编程方法 220

9.7 类与结构的比较 220

9.8 联合体 220

第10章 C++函数模板 221

10.1 函数模板基础 221

实例10-1 一个简单的函数模板 222

实例10-2 显示最小数 223

10.2 函数的定制 223

实例10-3 比较两个字符串 224

实例10-4 定制函数模板 225

10.3 使用模板排序 226

实例10-5 定义函数模板 226

实例10-6 对整数进行排序 227

第2单练习 229

第3单元 C++类与类模板 233

第11章 C++类 233

11.1 类的设计 233

11.1.1 类的声明 233

实例11-1 计算立方体的体积 234

11.1.2 类的成员 235

11.1.3 类成员的可见性 235

11.1.4 数据成员 236

11.1.5 初始化 236

11.1.6 成员函数 236

11.1.7 面向对象的类的设计方法 237

11.1.8 类对象的作用域 237

11.1.9 内联函数 237

实例11-2 使用内联函数计算立方体的体积 237

11.2 构造函数 239

11.2.1 使用默认参数的构造函数 239

实例11-3 用默认值来初始化 240

11.2.2 默认构造函数 240

11.2.3 重载构造函数 241

实例11-4 具有两个构造函数的类 241

11.3 析构函数 242

11.4 类的转换 243

11.4.1 转换函数 243

11.4.2 转换构造函数 243

实例11-5 从std::time_t对象到Date类对象的转换 243

11.4.3 成员转换函数 245

实例11-6 计算从20世纪开始至今的天数 245

11.4.4 类的转换 246

实例11-7 对两种日期进行转换 246

11.4.5 转换函数的调用 248

实例11-8 三种类转换形式 248

11.4.6 其他转换方法 250

实例11-9 多种转换方法 250

11.4.7 显式构造函数 252

11.4.8 表达式内部的转换 252

实例11-10 对两种日期进行转换 253

11.5 私有数据成员的使用 254

11.5.1 取值和赋值成员函数 254

实例11-11 通过成员函数来使用数据成员 254

11.5.2 常量成员函数 255

11.5.3 改进的成员转换函数 255

实例11-12 隐藏数据时的转换 255

11.6 友元 257

11.6.1 友元类 257

实例11-13 友元类的用法 257

11.6.2 隐式构造函数 258

11.6.3 前向引用 259

11.6.4 显式友元前向引用 259

实例11-14 不使用前向引用 259

11.6.5 友元函数 261

实例11-15 类的友元函数 261

11.6.6 匿名对象 262

11.6.7 非类成员的友元函数 262

实例11-16 用友元函数将两个类联系起来 262

11.7 析构函数的使用 264

实例11-17 使用析构函数显示月份 264

11.8 重载赋值运算符 266

实例11-18 类的赋值 266

11.9 this指针 268

11.9.1 以this指针作为返回值 269

实例11-19 this指针 270

11.9.2 在链表中使用this指针 272

实例11-20 this指针和链表 272

11.10 类对象数组 274

实例11-21 类的数组 274

11.10.1 类对象数组和默认构造函数 275

实例11-22 类数组的构造函数 276

11.10.2 类对象数组和析构函数 277

实例11-23 类数组的析构函数 277

11.11 静态成员 278

11.11.1 静态数据成员 278

实例11-24 静态成员和链表 278

11.11.2 静态成员函数 280

实例11-25 显示姓名 280

11.11.3 公有静态成员 282

11.12 类和堆 282

11.12.1 构造函数和析构函数 283

实例11-26 new和delete运算符 283

11.12.2 堆和类数组 284

实例11-27 错误地释放类数组所占内存 284

实例11-28 正确地删除对象数组指针 285

11.12.3 重载new和delete运算符 286

实例11-29 针对某个类的new和delete运算符 286

11.12.4 检测异常 288

11.12.5 重载new和delete中的异常处理 288

11.12.6 重载new[]和delete[] 289

实例11-30 针对类的new[]和delete[]运算符 289

11.13 副本构造函数 291

实例11-31 调用副本构造函数的两种方法 291

11.14 类的引用 293

实例11-32 使用了引用的类 294

11.15 构造函数的参数初始化表 296

11.16 对eonst修饰符的简单说明 296

11.17 可变的数据成员 299

实例11-33 使用可变数据成员 299

11.18 类的源文件和目标文件的管理 300

11.18.1 头文件中的类声明 300

11.18.2 库中的类成员函数 300

第12章 运算符重载 301

12.1 运算符重载的时机 301

12.2 运算符重载的一个例子 302

12.3 运算符重载的规则 302

12.4 双目算术运算符 303

12.5 作为类成员的运算符函数 304

实例12-1 重载+运算符 304

12.6 非类成员的运算符函数 306

实例12-2 用非类成员来重载+运算符 306

12.7 关系运算符 308

实例12-3 重载关系运算符 308

12.8 其他的赋值运算符 310

实例12-4 重载+=运算符 310

12.9 自增和自减运算符 311

实例12-5 重载++运算符 311

12.10 单目正、负运算符 313

实例12-6 重载单目负运算符 313

12.11 下标运算符 314

实例12-7 重载下标运算符[] 314

12.12 成员指针运算符 316

实例12-8 重载->运算符 317

第13章 类的继承 319

13.1 继承 319

13.2 为什么要使用继承 321

13.3 数据抽象类的设计 322

13.3.1 基类 322

实例13-1 声明类Date 322

13.3.2 效率设计 325

实例13-2 实现类Date 325

13.3.3 单继承 327

13.3.4 派生类 327

实例13-3 声明派生类 328

13.3.5 受保护的成员 328

13.3.6 派生类的成员和定制的成员 328

13.3.7 公有和私有的基类 329

13.3.8 基类和派生类的构造函数 329

13.3.9 定制新的成员函数 329

13.3.10 重定义基类的成员函数 330

实例13-4 实现类的静态数据成员和非内联成员函数 330

13.3.11 编写程序 330

实例13-5 通过继承定制抽象数据类型 331

13.3.12 用于基类和派生类的作用域运算符 331

实例13-6 类的作用域运算符 332

13.3.13 多个派生类 332

13.3.14 第二个派生类 333

实例13-7 CustomDate.h 333

实例13-8 CustomDate.cpp 333

13.3.15 使用基类和派生类 334

实例13-9 多个派生类 334

13.3.16 派生类之间的关系 335

13.3.17 从派生类派生出的类 335

实例13-10 SpeeialCustomDate.h 337

实例13-11 从派生类中派生类 338

13.4 类层次结构的设计 339

13.4.1 C++与纯面向对象的设计 339

13.4.2 数据抽象 340

13.4.3 重载运算符<<和>> 341

实例13-12 重载运算符<<和>> 342

实例13-13 使用重载运算符<<和>> 343

13.4.4 两个更为抽象的数据 343

实例13-14 Ssn.h 343

实例13-15 Ssn.cpp 344

实例13-16 Money.h 345

实例13-17 Money.cpp 345

13.4.5 包含头文件 346

13.4.6 C++标准字符串类 346

13.5 基类Person 346

实例13-18 Person.h 346

实例13-19 Person.cpp 348

13.5.1 类中的枚举数据类型 349

13.5.2 虚函数 349

13.5.3 纯虚函数 349

13.5.4 两种显示方式 349

13.6 派生类 350

13.6.1 类Employee 350

实例13-20 Employee.h 350

实例13-21 Employee.cpp 350

13.6.2 函数重载 351

13.6.3 类WagedEmployee 351

实例13-22 WagedEmployee.h 351

实例13-23 WagedEmployee.cpp 352

13.6.4 类SalariedEmployee 353

实例13-24 SalariedEmployee.h 353

实例13-25 SalariedEmployee.cpp 353

13.6.5 类Contractor 354

实例13-26 Contractor.h 354

实例13-27 Contractor.cpp 355

13.6.6 构造目标代码库 355

13.6.7 使用问题域类层次结构 356

实例13-28 人事管理应用程序 356

13.6.8 用引用方式调用虚函数 359

13.6.9 用引用方式调用非虚函数 360

13.6.10 对重定义的虚函数的调用 360

13.6.11 派生类没有重定义的虚函数 360

13.6.12 虚析构函数 360

实例13-29 基类非虚析构函数 361

实例13-30 基类的虚析构函数 361

13.6.13 应该定义为虚函数的成员函数 362

13.7 多态性 363

第14章 类的多重继承 365

14.1 多个基类 365

14.1.1 多重继承中的构造函数的执行 366

14.1.2 多重继承中的析构函数的执行 367

14.2 细化资产系统的设计 367

14.3 重定义多重继承中的成员 368

14.4 多重继承中的二义性 369

14.4.1 二义性成员函数 369

14.4.2 二义性数据成员 369

14.4.3 在设计时解决二义性问题 370

14.4.4 不可避免的二义性问题 371

14.5 虚基类 371

14.6 设计的实现 372

14.6.1 类DisplayObject 372

实例14-1 实现基类DisplayObject 372

14.6.2 类Vehicle 373

实例14-2 实现类Vehicle 373

14.6.3 类Property 373

实例14-3 实现类Property 373

14.6.4 类Asset和Expense 374

实例14-4 实现类Asset 374

实例14-5 实现类Expense 375

14.6.5 类Computer和Pencile 376

14.6.6 类CompanyCar和LeaseCar 376

实例14-6 实现类CompanyCar和LeaseCar 376

14.6.7 应用程序 376

实例14-7 多重继承 376

14.7 回顾 377

第15章 类模板 379

15.1 类模板的基本知识 379

15.2 声明模板类的多个对象 380

15.3 调用类模板的成员函数 380

15.4 声明多个参数 381

实例15-1 简单的类模板 381

实例15-2 为具体类型的参数提供默认值 382

15.5 有界数组类模板 383

实例15-3 类模板头文件 383

实例15-4 使用有界数组模板 384

15.6 何时使用类模板 385

15.7 链表模板 386

实例15-5 使用链表模板 386

15.7.1 整数值对象链表 390

实例15-6 使用整型值对象的链表类 390

15.7.2 日期对象链表 391

实例15-7 使用日期链表模板 391

15.8 定制模板 393

15.8.1 定制类模板 393

实例15-8 定制类模板 393

15.8.2 定制模板成员函数 394

实例15-9 定制显示成员函数 394

15.8.3 模板的部分定制 395

实例15-10 部分定制模板 395

15.9 类模板的默认参数 397

实例15-11 默认模板参数 397

第16章 面向对象的程序设计 399

16.1 基本知识 399

16.2 过程化程序设计 400

16.3 面向对象的程序设计 400

16.3.1 面向对象的程序 400

16.3.2 对象 401

16.3.3 抽象 402

16.3.4 封装 403

16.3.5 方法和消息 404

16.3.6 功能性方法 404

16.3.7 数据类型方法 404

16.3.8 隐式类型转换方法 405

16.3.9 成员函数 406

16.3.10 继承 406

16.3.11 单个继承 406

16.3.12 多重继承 406

16.3.13 类的关系 407

16.3.14 多态性 407

16.4 小结 407

第3单元练习 409

第4单元 C++标准库 413

第17章 标准库简介 413

17.1 类std::string 413

17.1.1 构造字符串 413

17.1.2 给字符串赋值 414

17.1.3 字符串连接 414

17.1.4 字符串的下标 414

17.1.5 字符串的比较 414

17.1.6 子串 415

17.1.7 搜索字符串 415

17.1.8 字符串操作 415

17.2 输入/输出流 416

17.2.1 流类 416

17.2.2 缓冲输出 417

17.2.3 格式化输出 417

实例17-1 使用成员函数put() 421

实例17-2 ostream的成员函数write() 421

实例17-3 istream的成员函数get() 422

实例17-4 为函数get()指定缓冲区地址和长度 423

实例17-5 istream的成员函数getline() 424

实例17-6 istream的成员函数read() 425

17.2.4 文件的输入/输出 425

17.3 类std::complex 427

实例17-7 类complex 428

17.4 标准模板类 428

17.5 标准异常 428

实例17-8 从C++标准库的exception类派生出异常类 430

第18章 格式化输出与字符串处理 431

18.1 格式化输出 431

实例18-1 显示浮点值 431

18.2 操纵算子、标志和成员函数 432

18.2.1 函数ios::width 432

实例18-2 利用成员函数width()控制输出宽度 432

18.2.2 操纵算子std::setw 433

实例18-3 以表格形式显示数据 433

18.2.3 函数std::ios::fill 434

实例18-4 用星号填充一列数 434

18.2.4 输出对齐 434

实例18-5 操纵算子setiosflags和resetiosflags 434

18.2.5 操纵算子setprecision 435

实例18-6 操纵算子setprecision 435

18.2.6 科学记数法和定点记数法 436

实例18-7 设置ios::fixed标志 436

18.2.7 函数std::ios::setf和std::ios::unsetf 437

18.2.8 格式化标志 437

18.2.9 格式化操纵算子 437

18.2.10 格式化函数 437

实例18-8 类std::istringstream 438

实例18-9 类std::ostringstream 438

实例18-10 类std::stringstream 439

第19章 C++输入/输出流 441

19.1 文件流类的层次结构 441

19.2 类std::ofstream 441

实例19-1 文件输出 441

实例19-2 向输出文件追加内容 442

实例19-3 避免打开现有的文件 443

实例19-4 把类对象的二进制表示记录到数据文件中 444

实例19-5 使用ofstream的成员函数 445

19.3 类ifstream 446

实例19-6 从文件中读取类Date的对象 447

19.3.1 读取文件直至文件结束 447

实例19-7 测试是否文件结束 447

19.3.2 在文件中定位 448

实例19-8 成员函数seekg() 448

实例19-9 确定输入的当前位置 449

19.3.3 读取和写入流文件 449

实例19-10 读写流文件 450

19.3.4 文件和流的关联与解除关联 450

实例19-11 成员函数open()和close() 450

19.4 二进制文件与文本文件 451

19.5 类std::fstrean 452

实例19-12 输入输出流 452

第4单元练习 453

第5单元 C++STL 459

第20章 STL概述 459

20.1 为什么需要STL 459

20.2 STL编程模型 460

20.2.1 序列 460

20.2.2 容器适配器 460

20.2.3 结合容器 461

20.2.4 指示器 461

20.2.5 算法 462

20.2.6 函数对象参数 462

20.2.7 内存分配器 462

第21章 序列在程序中的使用 463

21.1 序列容器简介 463

21.2 向量类模板 464

实例21-1 创建简单的向量 464

21.2.1 插入和访问向量元素 465

实例21-2 给向量添加元素 465

实例21-3 在向量中的任意位置插入元素 466

21.2.2 删除向量元素 467

实例21-4 从向量中删除元素 467

实例21-5 在向量中的任意位置删除元素 468

21.2.3 向量的比较 469

实例21-6 向量比较 469

21.2.4 向量的成员函数 470

21.3 双端队列类模板 471

实例21-7 创建一个简单的双端队列 471

21.3.1 插入和访问双端队列的元素 472

实例21-8 给双端队列添加元素 472

实例21-9 在双端队列的任意位置插入元素 473

21.3.2 删除双端队列的元素 474

实例21-10 删除字符序列中的字符 474

实例21-11 删除双端队列中任意位置处的元素 475

21.3.3 比较双端队列 476

实例21-12 比较双端队列 476

21.3.4 双端队列的成员函数 477

21.4 链表模板类 478

实例21-13 创建一个简单的链表 478

21.4.1 插入链表元素 479

实例21-14 给链表添加元素 479

实例21-15 在链表的任意位置插入元素 480

21.4.2 删除链表元素 481

实例21-16 从链表中删除元素 481

实例21-17 删除链表中任意位置处的元素 482

21.4.3 比较链表 483

实例21-18 比较链表 483

21.4.4 链表成员函数 484

21.5 容器适配器std::stack 485

实例21-19 管理堆栈 485

21.6 容器适配器std::queue 487

实例21-20 管理队列 487

21.7 容器适配器std::priority_queue 488

实例21-21 管理优先级队列 489

第22章 结合容器 491

22.1 介绍结合容器 491

22.2 类模板std::set 491

实例22-1 创建一个简单集合 492

22.2.1 插入集合元素 493

实例22-2 向集合中添加元素 493

22.2.2 删除集合中的元素 494

实例22-3 从一个集合中的任意位置删除元素 494

22.2.3 对集合进行搜索 495

实例22-4 在集合中查找一个元素 495

22.2.4 在集合之间进行比较 496

实例22-5 比较集合 496

22.2.5 集合的成员函数 497

22.3 类模板std::multiset 498

实例22-6 创建一个简单的多重集合 499

22.3.1 插入std::multiset元素 500

实例22-7 对一个多重集合添加元素 500

22.3.2 删除多重集合的元素 501

实例22-8 在一个多重集合的任意位置删除元素 501

22.3.3 对std::multiset进行搜索 502

实例22-9 搜索一个多重集合 502

22.3.4 在std::multiset集合之间进行比较 503

实例22-10 比较多重集合 503

22.3.5 多重集合的成员函数 505

22.4 类模板std::map 506

实例22-11 创建一个简单映射 506

22.4.1 插入map元素 507

实例22-12 为映射添加元素 507

实例22-13 使用[]操作符在std::map对象中插入元素 508

22.4.2 删除映射中的元素 509

实例22-14 删除映射中任意位置上的元素 509

22.4.3 对映射进行搜索 510

实例22-15 搜索一个映射 510

22.4.4 在映射之间进行比较 512

实例22-16 比较映射 512

22.4.5 映射成员函数 513

22.5 类模板std::multimap 514

实例22-17 创建并显示一个简单的多重映射 514

22.5.1 插入multimap元素 515

22.5.2 删除多重映射的元素 516

实例22-18 在多重映射的任意位置删除元素 516

22.5.3 搜索多重映射 517

实例22-19 搜索一个多重映射 517

22.5.4 对多重映射进行比较 518

实例22-20 比较多重映射 519

22.5.5 多重映射的成员函数 520

22.6 类模板std::bitset 521

22.6.1 在位集合中对位进行操作 521

实例22-21 std::bitset类成员函数的用法 522

22.6.2 在位集合中测试位 523

实例22-22 测试位 523

22.6.3 比较位集合 524

实例22-23 比较两个位集合 524

22.6.4 位集合的成员函数 526

22.7 用户定义的谓词 526

实例22-24 谓词 526

22.8 小结 529

第23章 通用算法 531

23.1 介绍通用算法 531

23.2 非修正序列算法 532

实例23-1 查找对象中相匹配的元素 532

实例23-2 确定集合中某值出现的次数 534

实例23-3 显示多重集合的内容 535

23.3 修正序列算法 536

实例23-4 用0来填充向量 537

实例23-5 打乱向量中的内容 538

实例23-6 把所有的数字5都放到向量的开端 539

实例23-7 重新组织向量中的字符 541

23.4 排序算法 542

实例23-8 向量排序 544

实例23-9 向量排序并将结果前置 546

实例23-10 std::nth_element()函数的用法 547

实例23-11 合并向量 549

实例23-12 查找向量中的相同部分 551

23.5 数值算法 552

实例23-13 计算某数值与每个元素之和 553

实例23-14 计算规定范围中元素的内积之和 554

实例23-15 计算规定范围中元素的部分和 555

实例23-16 计算规定范围中元素的相邻差 557

第24章 指示器 559

24.1 指示器简介 559

24.2 输入指示器 560

实例24-1 输入指示器的用法 560

24.3 输出指示器 561

实例24-2 输出指示器的用法 561

24.4 前向指示器 562

实例24-3 前向指示器的用法 562

24.5 双向指示器 564

实例24-4 双向指示器的用法 564

24.6 随机访问指示器 566

实例24-5 随机访问指示器的用法 566

24.7 特殊用途指示器 568

24.7.1 流指示器 568

实例24-6 输入流指示器的用法 568

实例24-7 输出流指示器的用法 570

24.7.2 指示器适配器 572

实例24-8 反向指示器的用法 572

实例24-9 用指示器来覆盖数值 574

实例24-10 用指示器插入数值 575

第25章 C++异常处理 577

25.1 C中的异常处理 577

25.2 C++中的异常处理 579

25.2.1 try块 579

25.2.2 catch异常处理器 580

25.2.3 throw语句 580

25.2.4 try/throw/catch系列 581

实例25-1 抛出并捕获异常 581

实例25-2 多个catch处理模块 583

25.2.5 异常情况指定 584

25.2.6 不可预见的异常 584

25.2.7 catch-all异常处理模块 584

实例25-3 catch-all模块行为 585

25.2.8 从处理模块中抛出异常 586

实例25-4 重新抛出异常 586

25.2.9 没有被捕获的异常 588

实例25-5 未经捕获的异常 588

实例25-6 捕获未经捕获的异常 589

25.3 在抛出的异常中进行选择 590

25.4 异常情况以及没有被释放的资源 591

25.5 一个改进的计算器程序 592

实例25-7 计算器 592

第5单元练习 597

第6单元 深入学习C++ 601

第26章 标准C++语言补充 601

26.1 名字空间 601

26.1.1 名字空间的介绍 602

26.1.2 有关名字空间的成员 602

实例26-1 std 602

26.1.3 using namespace语句 603

实例26-2 使用名字空间中定义的标识符 603

实例26-3 using namespace语句的问题 603

实例26-4 避开使用using namespace语句 604

26.1.4 定义名字空间 605

实例26-5 定义了各种类型变量和函数的名字空间 605

26.1.5 嵌套名字空间 606

实例26-6 嵌套 606

26.1.6 无名名字空间 607

26.1.7 名字空间的别名 607

实例26-7 别名 608

26.2 新风格类型转换 609

26.2.1 动态类型转换 609

实例26-8 向下转换指针 609

实例26-9 用动态类型转换向下转换引用 611

26.2.2 静态类型转换 613

实例26-10 静态类型转换与C风格类型转换 613

26.2.3 重新解释类型转换 614

实例26-11 用空指针返回100个字符缓冲区的内存分配 615

26.2.4 常类型转换 615

实例26-12 计数器 616

26.3 运行时类型信息 617

实例26-13 检测typeid行为 617

第27章 区域表示 619

27.1 国际化元素 619

27.2 std::locale类 620

27.2.1 标准侧面 620

27.2.2 默认区域表示与全局区域表示 620

27.3 生成区域表示对象 621

实例27-1 不同区域的日期显示 622

27.4 生成混合区域表示 623

实例27-2 日期混合显示 624

27.5 流与区域表示 625

实例27-3 imbue()函数 625

27.6 操作侧面 626

实例27-4 访问侧面 626

第6单元练习 628

第7单元 附录 631

附录A 数值系统 631

A.1 简介 631

A.2 将二进制数简化为八进制和十六进制数 633

A.3 将八进制和十六进制数转换为二进制数 634

A.4 将二进制、八进制和十六进制数转换为十进制数 634

A.5 将十进制数转换为二进制、八进制或十六进制数 635

A.6 负二进制数：补码表示法 636

A.7 知识点小结 637

附录B 运算符的优先级与结合律 639

附录C ASCII字符集 640

附录D C与C++的区别 641

D.1 返回值 641

D.2 类型检查 641

D.3 声明 641

D.4 名字 642

D.5 C++的一些优点 642

附录E 标准C++特性总结 643

E.1 新式头文件 643

E.2 ANSI类型转换运算符 644

E.3 模板与异常处理 644

E.4 其他关键字 645

E.5 if语句中变量的作用范围 645

E.6 具有枚举类型的函数的重载 646

E.7 嵌入类的前向引用 646

附录F 标准异常 648

附录G C++术语与概念 649

第7单元练习 685

习题集 687

练习答案 729