第1部分 基础准备及入门 1
第1章 引言 1
1.1 程序与软件 1
1.2 软件与软件工程 1
1.2.1 软件的特点 2
1.2.2 软件危机 2
1.2.3 软件工程 3
1.2.4 软件工程目标 3
1.3 计算机科学、计算机技术、计算机工程 3
1.4 软件工程文化 4
1.5 如何学好这门课程 4
1.5.1 掌握学科形态和核心概念 4
1.5.2 实现思维方式数学化 5
1.5.3 理解科学、提高科学素养 5
1.5.4 掌握本课程的知识内容 6
1.5.5 上机实践 6
第2章 软件开发的一般过程 7
2.1 分析与限定（用户需求分析） 7
2.2 分析与抽象、设计 8
2.3 编码、求解 8
2.4 系统组装、系统集成测试与调试 8
2.5 试运行、软件验收 9
2.6 软件发布 9
第3章 算法与数据结构抽象 10
3.1 信息与数据 10
3.2 数据、数据类型与数据结构 10
3.3 问题、算法与程序 10
3.4 算法与数据结构 11
3.5 抽象的重要性 11
第4章 实例HIS系统的分析与限定 12
4.1 问题的提出 12
4.2 分析与限定 12
4.3 用户需求 13
第5章 软件工程方法学与程序设计方法学 15
5.1 软件工程方法学和程序设计方法学 15
5.2 不同的程序设计方法 15
5.3 结构化程序设计方法 15
5.3.1 经典的结构化程序设计技术 16
5.3.2 扩展的结构化程序设计技术 16
5.3.3 结构化程序设计工具：流程图 16
5.3.4 实例HIS的结构化设计 17
5.4 面向对象程序设计方法 17
5.5 结构化程序设计与面向对象程序设计的关系 18
第6章 面向对象软件开发的基本概念 19
6.1 面向对象思想 19
6.2 面向对象的基本概念 19
6.2.1 对象与类 19
6.2.2 对象的特性 20
6.2.3 对象与消息 20
6.2.4 面向对象的三大特性 20
6.2.5 面向对象术语 22
6.3 软件工程管理和文档的重要性 22
6.3.1 软件工程管理 23
6.3.2 文档 23
第7章 C＋＋语言工具和BCB开发环境 24
7.1 C＋＋简介 24
7.2 Borland C++Builder简介 24
7.3 Borland C＋＋编辑、编译、调试环境简介 25
7.3.1 Borland C++6应用程序窗口 25
7.3.2 建立C＋＋源文件（．cpp） 25
7.3.3 程序调试窗口（Debug Windows） 27
思考与练习 29
第2部分 C＋＋程序设计 30
第8章 C＋＋程序简介 30
8.1 C＋＋环境基础 30
8.2 C＋＋编程简介 30
8.3 内存与外存 31
8.4 C＋＋程序结构 31
8.4.1 C＋＋程序的组成 32
8.4.2 C＋＋字符集、保留字与标识符 33
思考与练习 34
第9章 数据与基本数据类型 35
9.1 数据与对象 35
9.2 C＋＋的基本数据类型 35
9.2.1 常量及其类型 35
9.2.2 符号常量、const常量 39
9.2.3 变量及变量定义 39
9.2.4 基本类型数据的数值范围 40
9.3 基本数据类型的输入／输出 41
9.3.1 printf（）和scanf（）函数 42
9.3.2 输入、输出流对象cin、cout 44
9.4 C＋＋的数据类型 48
9.5 sizeof运算符 48
9.6 typedef（给类型起“别名”） 49
思考与练习 49
第10章 运算符、表达式与语句 50
10.1 C＋＋运算符及运算符的优先级和结合性 50
10.2 表达式 51
10.2.1 算术运算符与算术表达式 51
10.2.2 赋值运算符与赋值表达式 52
10.2.3 自增、自减运算符 53
10.2.4 关系运算符与关系表达式 54
10.2.5 逻辑运算符与逻辑表达式 55
10.2.6 条件运算符与条件表达式 56
10.2.7 复合赋值运算符与复合赋值表达式 56
10.2.8 逗号运算符与逗号表达式 56
10.2.9 位运算符与表达式 57
10.3 提高表达式的可读性 57
10.4 语句 57
10.4.1 空语句 58
10.4.2 复合语句 58
10.4.3 表达式语句 58
10.4.4 函数调用语句 58
10.4.5 定义语句 59
10.4.6 声明语句 59
10.4.7 控制语句 59
10.5 基本类型之间的转换 59
10.5.1 基本类型数据之间的运算 59
10.5.2 隐式类型转换 60
10.5.3 显式类型转换（强制类型转换） 60
思考与练习 61
第11章 控制结构 63
11.1 选择结构 63
11.1.1 if语句 63
11.1.2 switch语句 66
11.2 循环结构 68
11.2.1 for语句 68
11.2.2 while语句 69
11.2.3 do-while语句 71
11.3 goto语句 72
11.4 break语句 73
11.5 continue语句 74
思考与练习 74
第12章 程序功能与函数 77
12.1 C＋＋程序组件与函数 77
12.2 库函数 77
12.2.1 常用库函数 78
12.2.2 rand函数 79
12.3 函数定义 80
12.3.1 函数定义与形参 80
12.3.2 无参函数定义 80
12.3.3 有参函数定义 81
12.4 函数原型 81
12.5 函数声明 81
12.6 函数重载 82
12.7 函数调用 84
12.7.1 函数调用与实参 84
12.7.2 带参数缺省值的函数 84
12.7.3 函数调用机制 86
12.7.4 重载函数的调用 90
12.8 全局对象与局部对象 92
12.8.1 全局对象 92
12.8.2 局部对象 93
12.9 递归 94
12.9.1 函数的递归调用 94
12.9.2 递归实例 94
12.10 内联函数 96
12.11 实例HIS的功能组成 97
12.11.1 HIS的“角色”及其操作 97
12.11.2 HIS的功能列表 97
思考与练习 98
第13章 存储类型与作用域 101
13.1 函数的存储类型 101
13.1.1 外部函数 101
13.1.2 静态函数 102
13.2 数据对象的存储类型 102
13.2.1 自动存储类型（auto） 102
13.2.2 寄存器存储类型（register） 102
13.2.3 外部存储类型（extern） 103
13.2.4 静态存储类型（static） 104
13.3 对象标识符的作用域 104
13.3.1 块（局部）作用域 105
13.3.2 函数原型作用域 105
13.3.3 函数作用域 106
13.3.4 文件作用域 107
13.4 对象的生存期 108
13.4.1 静态生存期 108
13.4.2 动态生存期 108
13.5 标识符的可见性 109
13.5.1 可见性 109
13.5.2 作用域运算符 109
思考与练习 109
第14章 数组 111
14.1 数组基本概念及定义 111
14.1.1 数组的数据抽象 111
14.1.2 数组的定义 112
14.1.3 数组元素 112
14.1.4 数组长度 114
14.2 数组初始化 114
14.2.1 一维数组的初始化 114
14.2.2 二维数组的初始化 115
14.2.3 关于数组初始化的说明 115
14.3 字符串和字符数组 116
14.3.1 字符串结束标志 116
14.3.2 字符数组的输入、输出 116
14.4 数组应用举例 117
14.4.1 递归与迭代 117
14.4.2 一维数组应用举例 117
14.4.3 二维数组应用举例 121
思考与练习 122
第15章 指针 124
15.1 指针对象的定义与初始化 124
15.1.1 指针变量的定义 124
15.1.2 指针变量的初始化 124
15.2 取址与间接访问 125
15.2.1 取址运算符与取址表达式 125
15.2.2 间接访问运算符与间接访问表达式 125
15.2.3 定义指针和使用指针的区别 125
15.3 指针概念 126
15.3.1 内存与内存地址 126
15.3.2 指针与内存地址 127
15.3.3 指针的类型 128
15.3.4 值调用与引用调用 130
15.3.5 指针的破坏性 131
15.3.6 NULL指针 132
15.3.7 为什么要用指针 132
15.4 const限定符与指针 133
15.4.1 指向变量的指针变量 133
15.4.2 指向常量的指针变量 133
15.4.3 指向变量的指针常量 134
15.4.4 指向常量的指针常量 134
15.5 指针运算 134
15.6 指针与数组 135
15.6.1 数组名与指向数组的指针变量 135
15.6.2 一维数组与指针 135
15.6.3 二维数组与指针 136
15.6.4 指针数组 137
15.7 指针与函数 138
15.7.1 指针参数 138
15.7.2 返回指针的函数 139
15.8 函数指针 140
15.8.1 函数指针的定义 140
15.8.2 函数指针的应用 141
15.9 堆内存分配与new、delete运算符 142
15.9.1 new、delete运算符 143
15.9.2 关于动态分配的说明 143
15.10 例题：“数数”游戏 144
思考与练习 145
第16章 引用 147
16.1 “引用”与“引用”声明 147
16.1.1 声明“引用” 147
16.1.2 “引用”与“堆”对象 149
16.2 引用与函数 149
16.2.1 用“引用”参数按引用调用 149
16.2.2 用const限定形参 150
16.2.3 函数返回“引用” 151
16.2.4 函数调用作为左值 152
思考与练习 153
第17章 结构 154
17.1 构造新类型 154
17.1.1 声明结构类型 154
17.1.2 定义结构对象 155
17.1.3 结构对象的初始化 155
17.2 访问结构对象 155
17.2.1 同一结构类型的对象之间的赋值运算 156
17.2.2 访问结构成员 156
17.2.3 结构与数组 156
17.2.4 结构与函数 157
17.3 共用与枚举 158
17.3.1 共用 158
17.3.2 枚举 159
思考与练习 160
第18章 类与封装 161
18.1 软件方法发展的必然 161
18.1.1 “盲人摸象”与“面向对象” 161
18.1.2 数据抽象与信息隐藏 162
18.1.3 复合 162
18.1.4 接口与实现方法的分离 162
18.1.5 面向对象与面向过程 162
18.2 从结构到类 162
18.3 类的构成与声明 162
18.3.1 声明类 162
18.3.2 定义类的成员函数 163
18.3.3 类作用域 164
18.3.4 类的成员及其访问控制 165
18.4 定义对象与访问成员 166
18.4.1 类与对象 166
18.4.2 定义对象 166
18.4.3 访问对象成员 166
18.4.4 this指针 167
18.4.5 指向类成员的指针 167
18.5 构造函数与析构函数 169
18.5.1 构造函数与初始化对象 169
18.5.2 析构函数 174
18.5.3 构造函数与析构函数的说明 176
18.6 对象的赋值运算与“赋值”成员函数 176
18.7 拷贝构造函数 177
18.7.1 拷贝构造函数的声明与定义 177
18.7.2 缺省的拷贝构造函数 177
18.7.3 何时自动调用拷贝构造函数 179
18.8 构造函数用于类型转换 181
18.9 类的static成员 182
18.9.1 静态数据成员、静态成员函数 182
18.9.2 静态成员的必要性 183
18.10 const对象与const成员函数 183
18.10.1 const对象 183
18.10.2 const成员函数 183
18.11 实例分析 184
18.11.1 const对象与const成员函数：判断两直线是否平行 184
18.11.2 返回private成员的引用：破坏类的封装性 186
18.12 嵌套类与局部类 187
18.12.1 嵌套类 187
18.12.2 局部类 187
18.13 实例HIS的对象与类 188
思考与练习 188
第19章 继承 191
19.1 继承的概念 191
19.2 派生类的声明、定义 191
19.3 继承类别及其访问控制 194
19.3.1 公有继承 194
19.3.2 保护继承 195
19.3.3 私有继承 195
19.3.4 访问控制 196
19.4 派生类对象的构造与析构 198
19.5 继承关系中的指针 200
19.5.1 指针的指向 200
19.5.2 强制类型转换 201
19.6 在派生类中重定义基类成员函数 201
19.7 对象之间的关系 202
19.7.1 “是”关系 202
19.7.2 “有”关系 202
19.7.3 “知道”和“使用”关系 202
19.8 多重继承 203
19.9 虚拟继承 204
19.9.1 多继承的模糊性 204
19.9.2 虚基类与虚拟继承 204
19.10 复杂继承关系中派生类对象的构造顺序 206
19.11 实例HIS的类之间的关系 208
19.11.1 “是”（继承）关系 209
19.11.2 “有”关系 209
19.11.3 “知道”和“使用”关系 209
思考与练习 209
第20章 多态 212
20.1 多态性的工作方式 212
20.1.1 静态多态性 212
20.1.2 动态多态性 213
20.2 虚函数与多态性 213
20.2.1 虚函数的引入 213
20.2.2 虚函数的声明和定义 214
20.2.3 多态编程 214
20.2.4 正确使用虚函数 218
20.3 虚析构函数 221
20.4 纯虚函数与抽象类 222
20.4.1 纯虚函数 223
20.4.2 抽象类 223
20.4.3 关于抽象类的说明 223
20.5 实例HIS的多态性 224
思考与练习 224
第21章 友元 225
21.1 友元的声明和使用 225
21.1.1 友元函数 225
21.1.2 友元类 226
21.2 实例HIS中的友元 227
思考与练习 228
第22章 运算符重载 229
22.1 运算符重载的需要性 229
22.2 如何重载运算符 229
22.2.1 一元操作符重载的一般形式 229
22.2.2 二元操作符重载的一般形式 231
22.2.3 重载自增、自减运算符 232
22.2.4 重载赋值运算符 234
22.2.5 重载流插入运算符 235
22.3 运算符重载函数的返回 236
22.4 类型转换运算符 236
22.4.1 基本数据类型间的转换 236
22.4.2 构造类型与基本类型之间的转换 236
22.5 运算符重载的说明 237
22.6 例题：超长位数的整数的加、减运算 238
22.7 实例HIS中的操作符重载 244
思考与练习 245
第23章 输入／输出流与文件处理 247
23.1 I/O流类 247
23.1.1 iostream类库的头文件 247
23.1.2 输入／输出流类和对象 247
23.1.3 输入流 248
23.1.4 输出流 249
23.1.5 无格式输入／输出 249
23.2 格式控制 250
23.2.1 流操纵算子 250
23.2.2 用户自定义的流操纵算子 251
23.2.3 流格式状态及其设置 251
23.3 文件流 252
23.3.1 文件的组织 253
23.3.2 文件操作 253
23.4 串流类 255
23.5 实例HIS中的数据文件 256
思考与练习 256
第24章 异常处理 257
24.1 异常的基本概念 257
24.1.1 异常处理机制 257
24.1.2 异常指定 260
24.2 标准头文件〈exception〉 260
24.3 构造函数、析构函数的异常处理 263
24.4 new异常处理 264
24.5 auto_ptr模板类与动态内存分配 265
24.6 具有继承关系的类的异常处理 266
24.7 实例HIS中的异常处理 267
思考与练习 268
第25章 模板技术 269
25.1 模板简介 269
25.2 函数模板和模板函数 269
25.2.1 函数模板的声明和定义 270
25.2.2 函数模板的使用举例 270
25.2.3 函数模板的重载 272
25.3 类模板和模板类 273
25.3.1 类模板的声明 274
25.3.2 类模板的使用举例 274
25.4 类模板与继承 275
25.5 类模板的友元 275
25.6 类模板的static成员 276
25.7 实例HIS中的模板应用 276
思考与练习 276
第26章 常用数据结构 278
26.1 自引用类 278
26.2 动态数组 278
26.3 链 283
26.3.1 链的基本概念 283
26.3.2 链的基本操作 285
26.3.3 链应用举例 287
26.3.4 “链节点”类模板 295
26.3.5 “链”类模板 296
26.3.6 链模板使用举例 305
26.4 堆栈 306
26.4.1 栈的基本操作 306
26.4.2 从链模板派生栈模板 306
26.4.3 利用数组实现栈结构 308
26.5 队列 310
26.5.1 队列的基本操作 310
26.5.2 从链模板派生队列模板 310
26.5.3 利用数组实现环形队列 311
26.6 树 314
26.6.1 树的基本概念 314
26.6.2 二叉树 315
26.6.3 任何非二叉树转换为二叉树 315
26.6.4 二叉树的遍历 316
26.6.5 树节点和“树”类模板 317
26.6.6 计算算术表达式 321
26.7 图 321
26.7.1 图的基本概念 322
26.7.2 图结构的实现 322
26.8 实例HIS中的数据结构 323
思考与练习 324
第27章 排序与查找基本算法 325
27.1 排序 325
27.1.1 插入排序 325
27.1.2 选择排序 326
27.1.3 交换排序 327
27.2 查找 330
27.2.1 线性查找 330
27.2.2 二分查找 330
27.3 实例HIS中的排序与查找 331
思考与练习 332
第28章 标准模板库STL 333
28.1 容器简介 333
28.1.1 顺序容器 334
28.1.2 关联容器 338
28.1.3 容器适配器 340
28.2 迭代器简介 342
28.3 算法简介 344
第29章 预处理器、ANSI/ISO C＋＋补充 346
29.1 预处理器与预处理指令 346
29.1.1 宏定义 346
29.1.2 文件包含 347
29.1.3 条件编译 347
29.1.4 ＃error和＃pragma 348
29.1.5 行号 348
29.1.6 预定义的符号常量 348
29.1.7 断言（宏assert） 349
29.2 ANSI/ISO C＋＋补充 349
29.2.1 类型转换运算符 349
29.2.2 mutable存储类型 351
29.2.3 名空间 351
29.2.4 explicit构造函数 352
29.2.5 运算符关键字 352
29.2.6 程序运行时的类型信息（RTTI） 353
第30章 C＋＋编码标准 354
30.1 注释 354
30.1.1 注释的原则 354
30.1.2 函数注释 355
30.1.3 “战略性”注释、“战术性”注释 355
30.2 命名原则 356
30.3 函数 357
30.3.1 函数声明、定义 357
30.3.2 函数参数 358
30.3.3 函数返回值 358
30.3.4 函数重载 358
30.4 表达式和流程控制 359
30.4.1 表达式使用原则 359
30.4.2 goto语句 360
30.4.3 循环控制 360
30.5 宏 360
30.6 代码格式 360
30.7 初始化和清除 362
30.7.1 初始化基本原则 362
30.7.2 构造函数、拷贝构造函数 362
30.7.3 赋值成员函数 362
30.7.4 析构函数 362
30.7.5 内存分配和释放 362
30.8 类型的使用、转换 363
30.8.1 类型使用原则 363
30.8.2 类型转换原则 363
30.8.3 类的设计和使用 363
30.9 继承 364
30.9.1 继承的基本原则 364
30.9.2 多重继承 365
30.9.3 继承和模板的区别原则 365
30.10 操作符重载 365
30.11 友元 366
30.12 模板 366
30.12.1 模板使用的基本原则 366
30.12.2 模板编译的特殊性 366
30.13 异常处理 366
30.13.1 异常处理的基本原则 366
30.13.2 模板类型的异常 367
30.14 文件和目录 367
30.14.1 文件名 367
30.14.2 头文件 368
30.14.3 文件、目录的组织 368
30.15 编译 368
30.15.1 条件编译 368
30.15.2 编译原则 369
30.16 兼容性和性能 369
30.16.1 考虑兼容性 369
30.16.2 考虑性能要求 370
第31章 实例HIS的实现 371
31.1 数据文件 371
31.1.1 用户密码文件 371
31.1.2 医院“挂号科室”文件 371
31.1.3 药品文件 372
31.1.4 病人信息文件 372
31.1.5 病人就诊病史文件 372
31.1.6 病人就诊处方文件 372
31.2 源代码文件 373
31.2.1 类的声明和定义 373
31.2.2 其他程序文件 394
31.3 目录组织 411
31.4 编译、运行 412
31.4.1 组织文件 412
31.4.2 编写main函数文件 412
31.4.3 编译、运行程序 412
31.4.4 程序调试、维护 414
31.4.5 改进 416
参考文献 417