前篇 过程化的程序设计 1
第1章 C＋＋从这里开始 1
1.1 软件与程序 1
1.2 程序设计要做什么 2
1.3 选好一种语言 3
1.4 C＋＋能够做些什么 3
1.5 C语言、C＋＋语言和Visual C＋＋ 4
1.6 学习程序设计总体建议 5
1.7 C＋＋学习的常见问题 6
1.8 缩略语和术语表 8
1.9 方法指导 8
1.10 习题 8
第2章 Hello，World！ 10
2.1 Visual Studio 2012的安装和启动 10
2.2 如何创建一个程序 11
2.3 输出与输入 17
2.4 Visual C++6.0的使用 19
2.5 小巧的Dev-C＋＋ 22
2.5.1 Dev-C＋＋的安装 22
2.5.2 Dev-C＋＋的配置 23
2.5.3 Dev-C＋＋的使用 24
2.6 缩略语和术语表 26
2.7 方法指导 26
2.8 习题 26
第3章 各种各样的箱子——变量 28
3.1 会变的箱子 28
3.1.1 数据类型 28
3.1.2 变量名 29
3.1.3 变量的初始化 30
3.2 常用的基本数据类型 30
3.2.1 整型（Integer） 30
3.2.2 浮点型（Floating Point） 32
3.2.3 字符型（Character） 32
3.2.4 布尔型（Boolean） 33
3.3 不会变的箱子 33
3.4 算术表达式 34
3.4.1 操作符和表达式 34
3.4.2 算术操作符 35
3.5 箱子的转换 36
3.5.1 隐式转换 36
3.5.2 显式转换 36
3.6 缩略语和术语表 37
3.7 方法指导 38
3.8 习题 38
第4章 要走哪条路——分支结构 40
4.1 如果 40
4.1.1 条件——关系操作符 41
4.1.2 条件——逻辑操作符 44
4.1.3 ＆＆和‖的妙用 47
4.2 否则 47
4.2.1 如果与否则 48
4.2.2 如果里的如果 50
4.2.3 找朋友 51
4.3 爱判断的问号 52
4.4 切换的开关 52
4.4.1 多路开关——switch 53
4.4.2 巧用switch 55
4.5 缩略语和术语表 56
4.6 方法指导 56
4.7 习题 56
第5章 有个圈儿的程序——循环结构 61
5.1 程序赛车 61
5.1.1 循环语句for 61
5.1.2 加加和减减 63
5.1.3 巧用for 64
5.2 退出比赛和进维修站 65
5.2.1 退出比赛——break 65
5.2.2 进维修站——continue 66
5.3 圈圈里的圈圈 67
5.3.1 循环的嵌套 67
5.3.2 怎么让输出的东西更好看 68
5.4 当 70
5.4.1 当型循环 70
5.4.2 导火索——do 71
5.5 缩略语和术语表 73
5.6 方法指导 73
5.7 习题 73
第6章 好用的工具——函数 78
6.1 简单的工具 78
6.1.1 工具的说明书 78
6.1.2 如何使用系统造好的工具 80
6.2 打造自己的工具 81
6.2.1 函数的声明 82
6.2.2 函数的定义 82
6.2.3 函数是如何运行的 83
6.2.4 返回语句——return 83
6.2.5 关于主函数 83
6.2.6 同名同姓 84
6.2.7 函数存在的意义 85
6.3 多功能开瓶器——函数重载 86
6.4 自动的“工具” 88
6.4.1 默认参数 88
6.4.2 定义默认参数的顺序 89
6.4.3 默认参数和重载函数的混淆 89
6.5 给变量和参数起个“绰号”——引用 90
6.5.1 引用的声明 90
6.5.2 用引用传递参数 91
6.6 函数里的函数——递归 92
6.7 缩略语和术语表 93
6.8 方法指导 93
6.9 习题 94
第7章 好大的“仓库”——数组 98
7.1 让计算机处理更多数据——使用数组 98
7.1.1 数组的声明 98
7.1.2 数组的操作 99
7.1.3 数组的初始化 100
7.1.4 省略数组大小 100
7.2 仓库是怎样造成的 101
7.2.1 内存和地址 101
7.2.2 数组在内存中的存储情况 101
7.2.3 字符的存储情况 102
7.2.4 字符数组在内存中的存储情况 103
7.3 向函数传递数组 104
7.4 二维数组 106
7.4.1 线与面 106
7.4.2 二维数组的声明和初始化 107
7.4.3 省略第一维的大小 108
7.4.4 二维数组在内存中的存储情况 108
7.4.5 向函数传递二维数组 108
7.4.6 二维数组转化成一维数组 109
7.5 缩略语和术语表 110
7.6 方法指导 110
7.7 习题 110
第8章 内存里的快捷方式——指针 114
8.1 什么是指针 114
8.2 指针变量的声明和使用 114
8.2.1 指针的类型 115
8.2.2 指针变量的声明 115
8.2.3 获取地址和指针变量初始化 115
8.2.4 特殊的值——NULL 116
8.2.5 指针的使用——间接引用 116
8.3 指针的操作 117
8.3.1 指针的加减运算 117
8.3.2 指针的关系运算 118
8.4 指针与保护 118
8.4.1 对内存只读的指针 118
8.4.2 指针型常量 119
8.5 指针与数组 119
8.5.1 数组名的实质 120
8.5.2 指针数组 120
8.6 指针与函数 121
8.6.1 指针作为参数 121
8.6.2 指针作为返回值 122
8.7 更灵活的存储 123
8.7.1 如何获得堆内存空间 123
8.7.2 有借有还，再借不难 123
8.8 缩略语和术语表 124
8.9 方法指导 125
8.10 习题 125
第9章 自己设计的箱子——枚举和结构 129
9.1 我的类型我做主——枚举类型 129
9.2 设计一个收纳箱——结构类型 131
9.3 结构与函数 134
9.3.1 结构作为参数 134
9.3.2 结构作为返回值 135
9.4 结构数组与结构指针 136
9.4.1 结构数组 136
9.4.2 结构指针 136
9.5 自行车的链条——链表 137
9.6 链表的实现 139
9.6.1 链表的创建和遍历 139
9.6.2 链表的查询 141
9.6.3 插入结点 142
9.6.4 删除结点 144
9.6.5 清除链表 145
9.7 缩略语和术语表 146
9.8 方法指导 146
9.9 习题 147
中篇 实战程序设计 151
第10章 如何阅读程序代码 151
10.1 整体把握法 151
10.1.1 阅读代码的顺序 151
10.1.2 整体把握语意 152
10.2 经验法 153
10.3 模拟法 154
10.4 方法指导 155
10.5 习题 156
第11章 如何调试程序代码 159
11.1 再谈变量 159
11.1.1 标识符 159
11.1.2 全局变量和局部变量 159
11.1.3 静态局部变量 161
11.1.4 变量的作用域 163
11.1.5 变量的可见性 164
11.2 头文件的奥秘 165
11.2.1 如何创建一个头文件 165
11.2.2 头文件里有什么 166
11.2.3 头文件和源文件 168
11.2.4 细说＃include 168
11.2.5 尖括号和双引号的区别 168
11.2.6 外部依赖项 169
11.3 更快更好地完成程序调试 170
11.3.1 如何检查语法错误 170
11.3.2 常见语法错误及解决方法 173
11.4 最麻烦的问题 174
11.4.1 见识运行时错误 174
11.4.2 查找错误点 175
11.5 在VS2012里调试程序 178
11.5.1 如何设置和移除断点 178
11.5.2 走起 178
11.5.3 调试工具栏 179
11.5.4 监视和自动窗口 180
11.5.5 如何通过调试找到错误 181
11.6 缩略语和术语表 181
11.7 方法指导 181
11.8 习题 182
第12章 如何编写程序代码 185
12.1 程序设计的基本步骤 185
12.2 三类问题 186
12.2.1 算 186
12.2.2 找 187
12.2.3 实现功能 188
12.3 函数的递归 190
12.3.1 什么是栈 190
12.3.2 函数的调用机制 190
12.3.3 小试牛刀——用递归模拟栈 192
12.3.4 递归的精髓 193
12.4 缩略语和术语表 195
12.5 方法指导 195
12.6 习题 196
第13章 异常的处理 198
13.1 亡羊也要补牢 198
13.2 处理异常 199
13.2.1 尽力尝试 200
13.2.2 抓住异常 200
13.3 抛出异常 202
13.4 缩略语和术语表 203
13.5 方法指导 203
13.6 习题 204
后篇 面向对象的程序设计 205
第14章 初识对象 205
14.1 对象就是物体 205
14.2 一个字符串也是对象 205
14.2.1 奇妙的点 206
14.2.2 对字符串的操作 206
14.3 面向对象特点一：封装性 208
14.4 缩略语和术语表 208
14.5 方法指导 208
14.6 习题 209
第15章 再识对象 210
15.1 类是一种数据类型 210
15.1.1 类与结构 210
15.1.2 类的声明与定义 211
15.2 公有和私有 211
15.3 成员函数 212
15.3.1 成员函数的声明 212
15.3.2 常成员函数 212
15.3.3 成员函数的重载 213
15.3.4 成员函数的定义 213
15.4 如何方便地查看类 215
15.5 对象、引用和指针 216
15.5.1 对象的引用 216
15.5.2 对象指针 216
15.6 缩略语和术语表 216
15.7 方法指导 216
15.8 习题 217
第16章 造物者与毁灭者——对象生灭 220
16.1 麻烦的初始化 220
16.2 造物者——构造函数 221
16.2.1 构造函数的声明与定义 221
16.2.2 带参数的构造函数 222
16.3 先有结点，还是先有链表 224
16.4 克隆技术——拷贝构造函数 225
16.4.1 拷贝构造函数 225
16.4.2 默认拷贝构造函数 228
16.4.3 拷贝构造函数存在的意义 228
16.5 毁灭者——析构函数 232
16.6 缩略语和术语表 235
16.7 方法指导 235
16.8 习题 236
第17章 共有财产·好朋友·操作符 239
17.1 有多少个结点 239
17.1.1 静态成员数据 240
17.1.2 静态成员数据的初始化 240
17.1.3 静态成员函数 240
17.2 类的好朋友 243
17.2.1 友元类 243
17.2.2 友元函数 246
17.2.3 友元的利与弊 248
17.3 多功能的操作符——操作符的重载 248
17.3.1 操作符作为成员函数 249
17.3.2 操作符作为友元函数 252
17.3.3 又见加加和减减 254
17.4 缩略语和术语表 256
17.5 方法指导 256
17.6 习题 256
第18章 父与子——类的继承 257
18.1 剑士·弓箭手·法师的困惑 257
18.2 面向对象特点二：继承性 258
18.3 继承的实现 259
18.3.1 私有和保护 259
18.3.2 一个简单的例子 259
18.3.3 继承的方式 261
18.4 子类对象的生灭 265
18.4.1 子类对象的构造 265
18.4.2 子类对象的析构 267
18.5 继承与对象指针 268
18.5.1 父类指针与子类对象 268
18.5.2 猜猜它是谁 269
18.6 面向对象特点三：多态性 270
18.7 多态与虚函数 271
18.7.1 多态的实现 271
18.7.2 无法实现多态的虚函数 273
18.8 虚析构函数 274
18.9 抽象类与纯虚函数 276
18.10 多重继承 278
18.11 缩略语和术语表 279
18.12 方法指导 279
18.13 习题 280
第19章 再谈输入与输出 286
19.1 cout和cin是什么 286
19.2 输入／输出的重定向 286
19.2.1 输入重定向 286
19.2.2 输出重定向 287
19.2.3 无法被重定向的cerr 288
19.3 文件的输入与输出 289
19.4 更巧妙地输入和输出 290
19.4.1 能整行输入的getline 290
19.4.2 能读取判断末尾的eof 291
19.4.3 能计数的gcount 292
19.4.4 能设置域宽的width 292
19.5 插入操作符的重载 293
19.5.1 插入操作符 293
19.5.2 插入操作符的常用重载方式 294
19.6 缩略语和术语表 295
19.7 方法指导 295
19.8 习题 295
第20章 万用的模板 297
20.1 函数模板 297
20.1.1 从为什么需要模板说起 297
20.1.2 声明与定义函数模板 298
20.1.3 函数模板与重载 299
20.2 类模板 301
20.2.1 类模板的声明和定义 301
20.2.2 链表类模板实例 301
20.3 从数组到向量 306
20.3.1 向量的性能 306
20.3.2 对向量的操作 306
20.4 缩略语和术语表 307
20.5 方法技巧 307
20.6 习题 307
第21章 博大精深的STL 312
21.1 STL里有什么 312
21.2 超级指针——迭代器 313
21.3 有了算法，何必还需自己写 314
21.4 从箱子到容器 316
21.4.1 链表，再见！ 316
21.4.2 交集和并集 318
21.5 函数也能是对象 320
21.6 空间分配好管家 322
21.7 缩略语和术语表 323
21.8 方法指导 323
21.9 习题 324
附录A 常用保留字列表 326
附录B 常见编译错误和解决方法 328
附录C 参考文献 331
附录D 推荐书目 332