1.1　软件与程序　1
1.2　程序设计要做什么　1
1.3　选好一种语言　2
1.4　C++能够做些什么　2
1.5　C语言、C++和Visual C++的关系　2
1.6　学习程序设计的方法和必要准备　3
1.7　总结　3
第2章　Hello，World　4
2.1　如何创建一个示例程序　4
2.2　创建自己的Hello，World　6
2.3　C++语言的输出与输入　8
2.4　方法指导　10
2.5　习题　10
第3章　各种各样的“箱子”——变量　12
3.1　会变的“箱子”——定义变量　12
3.1.1　C++数据类型　12
3.1.2　变量名　13
3.1.3　变量的初始化　13
3.2　常用的基本数据类型　14
3.2.1　整型(Integer)　14
3.2.2　实型(Real)　14
3.2.3　字符型(Character)　14
3.2.4　布尔型(Boolean)　15
3.3　不会变的“箱子”——定义常量　15
3.4　C++算术表达式　15
3.4.1　赋值　16
3.4.2　除、整除和取余　16
3.5　“箱子”的转换——数据类型转换　17
3.5.1　隐式转换　17
3.5.2　显式转换　17
3.6　方法指导　18
3.7　习题　18
第4章　要走哪条路——条件语句　20
4.1　如果……　20
4.1.1　条件——关系运算　20
4.1.2　条件——逻辑运算　22
4.1.3　&&和||的妙用　24
4.2　否则……　24
4.2.1　如果与否则　25
4.2.2　如果里的如果——if的嵌套　25
4.2.3　找朋友　27
4.3　爱判断的问号　28
4.4　切换的开关　28
4.4.1　多路开关——switch　29
4.4.2　巧用switch　30
4.5　方法指导　32
4.6　习题　32
第5章　有个圈儿的程序——循环语句　36
5.1　程序赛车　36
5.1.1　循环语句for　36
5.1.2　加加和减减　37
5.1.3　巧用for　39
5.2　退出比赛和进维修站　40
5.2.1　退出比赛——break　40
5.2.2　进维修站——continue　41
5.3　圈圈里的圈圈　41
5.3.1　C++循环的嵌套　41
5.3.2　怎么让输出的东西更好看　43
5.4　While循环　44
5.4.1　当型循环　44
5.4.2　导火索——do　45
5.5　方法指导　47
5.6　习题　47
第6章　好用的“工具”——函数　51
6.1　简单的“工具”——函数　51
6.1.1　“工具”的说明书　51
6.1.2　如何使用系统造好的“工具”　53
6.2　打造自己的“工具”　54
6.2.1　C++函数的声明　54
6.2.2　函数的定义　55
6.2.3　函数是如何运行的　56
6.2.4　返回语句——return　56
6.2.5　关于主函数　56
6.2.6　同名同姓——参数定义　57
6.2.7　函数存在的意义　58
6.3　多功能“开瓶器”——函数重载　59
6.4　自动的“工具”　61
6.4.1　默认参数　61
6.4.2　定义默认参数的顺序　61
6.4.3　默认参数和重载函数的混淆　62
6.5　给变量和参数起个“绰号”——引用　62
6.5.1　引用的声明　62
6.5.2　用引用传递参数　63
6.6　*函数里的函数——递归　64
6.7　方法指导　65
6.8　习题　66
第7章　好大的“仓库”——数组　69
7.1　让计算机处理更多数据——使用数组　69
7.1.1　C++中数组的声明　69
7.1.2　数组的操作　69
7.1.3　数组的初始化　71
7.1.4　省略数组大小　71
7.2　仓库是怎样造成的　71
7.2.1　内存和地址　72
7.2.2　C++数组在内存中的存储情况　72
7.2.3　字符的存储情况　73
7.2.4　字符数组在内存中的存储情况　74
7.3　向函数传递数组　75
7.4　C++二维数组　77
7.4.1　线与面——一维数组和二维数组　77
7.4.2　二维数组的声明和初始化　78
7.4.3　省略第一维的大小　79
7.4.4　二维数组在内存中的存储情况　79
7.4.5　向函数传递二维数组　79
7.4.6　二维数组转化成一维数组　80
7.5　方法指导　80
7.6　习题　81
第8章　内存里的快捷方式——指针　84
8.1　什么是指针　84
8.2　C++中指针变量的声明和使用　84
8.2.1　指针的类型　84
8.2.2　指针变量的声明　85
8.2.3　获取地址和指针变量初始化　85
8.2.4　特殊的值——NULL　85
8.2.5　指针的使用——间接引用　85
8.3　指针的操作　86
8.3.1　指针的加减运算　87
8.3.2　指针的关系运算　88
8.4　指针与保护　88
8.4.1　对内存只读的指针　88
8.4.2　指针型常量　88
8.5　指针与数组　89
8.5.1　数组名的实质　89
8.5.2　指针数组　90
8.6　指针与函数　90
8.6.1　指针作为参数　90
8.6.2　指针作为返回值　91
8.7　更灵活的存储——堆内存空间　92
8.7.1　如何获得堆内存空间　92
8.7.2　有借有还，再借不难——堆内存的回收　93
8.8　方法指导　94
8.9　习题　94
第9章　自己设计的箱子——枚举和结构　98
9.1　我的类型我做主——枚举类型　98
9.2　设计一个收纳箱——定义结构类型　100
9.3　C++结构与函数　103
9.3.1　结构作为参数　103
9.3.2　结构作为返回值　104
9.4　C++结构数组与结构指针　105
9.4.1　结构数组　105
9.4.2　结构指针　105
9.5　自行车的链条——链表　106
9.6　C++链表的实现　107
9.6.1　链表的创建和遍历　108
9.6.2　链表的查询　110
9.6.3　插入结点　111
9.6.4　删除结点　112
9.6.5　清除链表　114
9.7　方法指导　115
9.8　习题　115
第二篇　实战程序设计
第10章　高效阅读程序代码　119
10.1　整体把握法　119
10.1.1　阅读C++代码的顺序　119
10.1.2　整体把握语意　120
10.2　经验法　121
10.3　模拟法　122
10.4　方法指导　123
10.5　习题　124
第11章　调试程序代码技巧　127
11.1　再谈变量　127
11.1.1　标志符　127
11.1.2　C++全局变量和局部变量　127
11.1.3　静态局部变量　129
11.1.4　变量的作用域　130
11.1.5　变量的可见性　132
11.2　C++头文件的奥秘　133
11.2.1　如何创建一个头文件　133
11.2.2　C++程序中头文件的作用　134
11.2.3　头文件和源文件　135
11.2.4　细说#include　136
11.2.5　#include中尖括号和双引号的区别　136
11.3　更快更好地完成程序调试　137
11.3.1　如何检查语法错误　138
11.3.2　常见语法错误及解决方法　140
11.4　最麻烦的问题——运行时错误　141
11.4.1　见识运行时错误　141
11.4.2　查找错误点　142
11.5　调试工具——Debug　144
11.5.1　设置和移除断点　145
11.5.2　Go语句　145
11.5.3　Debug窗口　146
11.5.4　Watch窗口　147
11.5.5　用Debug找到错误　147
11.6　方法指导　147
11.7　习题　148
第12章　编写程序技巧　150
12.1　程序设计的基本步骤　150
12.2　三类C++编程问题　150
12.2.1　算法实现　150
12.2.2　匹配实现　151
12.2.3　功能实现　153
12.3　函数的递归　155
12.3.1　什么是栈　155
12.3.2　函数的调用机制　155
12.3.3　小试牛刀——用递归模拟栈　157
12.3.4　*递归的精髓　158
12.4　方法指导　160
12.5　习题　160
第三篇　面向对象的程序设计
第13章　初识对象　163
13.1　对象的定义　163
13.2　一个字符串也是对象　163
13.2.1　奇妙的点　164
13.2.2　对字符串的操作　164
13.3　面向对象特点一：封装性　166
13.4　从数组到向量　166
13.4.1　向量的性能　166
13.4.2　万用的模板　166
13.4.3　对向量的操作　167
13.5　方法指导　168
13.6　习题　168
第14章　再识对象　169
14.1　类是一种数据类型　169
14.1.1　类与结构　169
14.1.2　类的声明与定义　169
14.2　公有和私有　170
14.3　成员函数　171
14.3.1　成员函数的声明　171
14.3.2　常成员函数　171
14.3.3　成员函数的重载　172
14.3.4　成员函数的定义　172
14.4　对象、引用和指针　174
14.4.1　对象的引用　174
14.4.2　对象指针　174
14.5　方法指导　175
14.6　习题　175
第15章　造物者与毁灭者——对象生灭　178
15.1　麻烦的初始化　178
15.2　造物者——构造函数　178
15.2.1　构造函数的声明与定义　179
15.2.2　带参数的构造函数　180
15.3　先有结点，还是先链表　183
15.4　“克隆”技术——拷贝构造函数　186
15.4.1　拷贝构造函数　187
15.4.2　默认拷贝构造函数　192
15.4.3　拷贝构造函数存在的意义　192
15.5　毁灭者——析构函数　197
15.6　方法指导　203
15.7　习题　203
第16章　共有财产·好朋友·操作符　206
16.1　有多少个结点　206
16.1.1　静态成员数据　206
16.1.2　静态成员数据的初始化　207
16.1.3　静态成员函数　207
16.2　类的好朋友——友元　211
16.2.1　友元类　211
16.2.2　友元函数　216
16.2.3　使用友元的利与弊　218
16.3　多功能的操作符——操作符的重载　219
16.3.1　操作符作为成员函数　219
16.3.2　操作符作为友元函数　223
16.3.3　又见加加和减减　225
16.4　方法指导　227
16.5　习题　227
第17章 父与子——继承　228
17.1　剑士·弓箭手·法师的困惑　228
17.2　面向对象特点二：继承性　229
17.3　继承的实现　229
17.3.1　私有和保护　229
17.3.2　一个简单的例子　230
17.3.3　继承的方式　233
17.4　子类对象的生灭　239
17.4.1　子类对象的构造　239
17.4.2　子类对象的析构　241
17.5　继承与对象指针　242
17.5.1　父类指针与子类对象　242
17.5.2　猜猜它是谁——覆盖　244
17.6　面向对象特点三：多态性　245
17.7　多态与虚函数　245
17.7.1　多态的实现　246
17.7.2　无法实现多态的虚函数　249
17.8　虚函数与虚析构函数　250
17.9　抽象类与纯虚函数　252
17.10　多重继承　255
17.11　方法指导　256
17.12　习题　256
第18章　再谈输入与输出　273
18.1　cout和cin真正含义　273
18.2　输入输出的重定向　273
18.2.1　输入重定向　273
18.2.2　输出重定向　274
18.2.3　无法被重定向的cerr　275
18.3　文件的输入与输出　276
18.4　更巧妙地输入和输出　277
18.4.1　能整行输入的getline　277
18.4.2　能读取判断末尾的eof　278
18.4.3　能计数的gcount　279
18.4.4　能设置域宽的width　279
18.5　插入操作符的重载　280
18.5.1　插入操作符　280
18.5.2　插入操作符的常用重载方式　281
18.6　方法指导　283
18.7　习题　283

第3章 开始C++之旅
3.1 神奇的“向导”——创建控制台程序
3.2 HelloWorld示例
3.3 解释这个C++程序
3.4 创建自己的HelloWorld
3.5 小结
3.6 小测试

第4章 C++基本功
4.1 数据与程序的区别
4.1.1 烹饪的菜谱——程序
4.1.2 烹饪的菜品——数据
4.2 标识符与关键字
4.2.1 什么是标识符
4.2.2 需要注意的关键字
4.3 分隔符与注释符
4.3.1 划分语句的分隔符
4.3.2 使语句无效的注释符
4.4 各式各样的“口袋”——变量
4.4.1 程序中的会变的“口袋”——定义变量
4.4.2 变量的数据类型
4.4.3 变量名
4.4.4 变量的初始化
4.5 常用的基本数据类型
4.5.1 整数型
4.5.2 实数型
4.5.3 字符型与字符串
4.5.4 布尔型
4.6 程序中的不会变的“口袋”——常量
4.6.1 创造不会变的口袋——定义常量
4.6.2 各种进制的常量
4.7 给变量起个“绰号”——引用
4.8 综合应用——用程序来计算圆的面积
4.9 小结
4.10 小测试

第5章 C++的基本招式
5.1 C++中的运算符与表达式
5.1.1 运算符与表达式
5.1.2 算术运算符
5.1.3 赋值运算符
5.1.4 “加加”和“减减”
5.1.5 复合运算符
5.1.6 位运算符
5.1.7 关系运算符
5.1.8 不像运算符的运算符
5.2 运算符的优先级和结合性
5.3 各种“口袋”之间的转换
5.3.1 隐式转换
5.3.2 显式转换
5.4 小结
5.5 小测试

第6章 让C++程序听话——控制语句
6.1 构成C++程序的基本——语句
6.1.1 表达式语句与空语句
6.1.2 复合语句
6.2 让程序选择自己的路——条件选择语句
6.2.1 如果与否则
6.2.2 逻辑运算符的使用——&&和||
6.2.3 爱判断的问号
6.3 不怕重复的工作者——循环语句
6.3.1 当型循环while
6.3.2 当型循环的兄弟do-while
6.3.3 循环语句for
6.3.4 省略表达式1的for语句
6.3.5 省略表达式2的for语句
6.3.6 省略表达式3的for语句
6.3.7 省略表达式1和3的for语句
6.3.8 3个表达式全部省略的for语句
6.3.9 与循环变量无关的for语句
6.4 多样的选择——switch
6.4.1 用switch对学生成绩进行分类
6.4.2 多个执行结果共用1个条件
6.5 循环的嵌套
6.5.1 while语句的自身嵌套
6.5.2 for语句的自身嵌套
6.5.3 do-while语句的自身嵌套
6.5.4 for语句循环内嵌套while循环
6.5.5 while语句循环内嵌套多重for循环
6.5.6 do-while语句内嵌套其他类型的多重循环
6.6 退出与跳过
6.6.1 退出——break
6.6.2 跳过——continue
6.7 控制语句综合示例
6.7.1 四则运算深入学习while和switch
6.7.2 判断用户输入的数是否是素数——深入学习循环和条件判断
6.8 小结
6.9 小测试

第7章 C++程序中的“经理”——函数
7.1 明白什么是“经理”——函数的概念
7.1.1 什么是函数
7.1.2 使用函数的好处
7.1.3 程序中的“总经理”——Main函数
7.2 如何培养自己的“经理”
7.2.1 函数的定义
7.2.2 C++中函数的声明
7.3 给你的“经理”更多的资源——函数的参数
7.3.1 形式参数与实际参数
7.3.2 函数的计算的结果——函数的返回值
7.3.3 函数参数的求值顺序
7.3.4 可以包含默认的初始化参数
7.3.5 参数的修饰符
7.4 使用程序中的“经理”——函数的调用
7.4.1 函数调用表达式
7.4.2 函数调用的方式
7.4.3 函数的传值调用
7.4.4 函数的引用调用
7.5 如何让一个“经理”有更多的能力——函数的重载
7.5.1 参数类型上不同的重载函数
7.5.2 参数个数上不同的重载函数
7.6 “经理”间的协助——函数的嵌套调用
7.7 特殊的“经理”——内联和递归函数
7.7.1 内联函数
7.7.2 递归函数
7.8 “挖墙角”——使用C++的系统函数
7.8.1 系统函数的使用
7.8.2 字符串处理函数
7.9 小结
7.10 小测试

第8章 决定生存的权力——存储分类符
8.1 存储分类符和作用域
8.1.1 存储分类符的意义
8.1.2 什么是作用域
8.2 各种各样分类符的作用域及其生存期
8.2.1 自动变量
8.2.2 寄存器变量
8.2.3 静态变量
8.2.4 外部变量
8.3 内部函数和外部函数
8.3.1 内部函数
8.3.2 外部函数
8.4 小结
8.5 小测试

第9章 C++中的“大口袋”——数组
9.1 编了号的“大口袋”
9.1.1 内存中的大口袋——数组的概念
9.1.2 如何创造一个“大口袋”——数组的声明和定义
9.2 搞明白数组在内存中如何存储
9.3 “大口袋”的特性
9.3.1 在声明时初始化数组
9.3.2 数组元素的访问
9.3.3 数组可以传递给函数
9.4 二维数组
9.4.1 二维数组的声明和初始化
9.4.2 省略第一维的大小
9.4.3 二维数组在内存中的存储方式
9.4.4 二维数组元素的访问
9.4.5 二维数组转换为一维数组
9.5 只装“字符”的数组
9.5.1 创造字符数组及其初始化
9.5.2 字符数组元素的访问
9.5.3 特殊的字符串结束符
9.6 小结
9.7 小测试

第10章 让人迷惑的指针
10.1 变量的“向导”——指针
10.2 指针变量的声明和使用
10.2.1 指针变量的类型
10.2.2 指针变量的声明
10.2.3 获得地址并对指针变量进行初始化
10.2.4 特殊的值——NULL
10.2.5 指针的使用
10.2.6 指向指针变量的指针
10.3 指针变量的操作
10.3.1 指针变量的加减运算
10.3.2 指针变量的关系运算
10.4 数组、字符串和指针
10.4.1 数组和指针
10.4.2 一维数组中元素的指针表示法
10.4.3 二维数组的指针表示法
10.4.4 字符串和指针
10.5 常量指针与指针常量
10.5.1 常量指针
10.5.2 指针常量
10.6 指针与函数
10.6.1 指针作为参数
10.6.2 指针作为返回值
10.7 C++中灵活的空间——堆内存
10.7.1 如何获得堆内存并使用
10.7.2 如何释放堆内存
10.8 小结
10.9 小测试

第11章 自己设计的数据类型——结构
11.1 自定义的数据类型——结构的概念
11.2 如何制作自定义数据类型——结构类型的声明
11.3 结构类型变量的定义
11.3.1 结构类型变量的定义
11.3.2 typedef的使用
11.4 对结构变量的赋值
11.5 结构成员的访问
11.6 特殊的自定义类型——枚举类型
11.6.1 有限的可能性——枚举
11.6.2 枚举变量的声明和赋值
11.7 结构类型的数组和指针
11.7.1 结构数组
11.7.2 结构指针
11.8 结构与函数
11.8.1 结构作为参数
11.8.2 结构作为返回值
11.9 结构中的结构
11.9.1 指针变量作为结构成员
11.9.2 结构变量作为结构成员
11.10 小结
11.11 小测试

第12章 C++的预处理程序指令
12.1 C++的预处理功能
12.2 INCLUDE命令
12.3 简单的字符串替换
12.3.1 宏定义
12.3.2 取消宏定义
12.4 定义宏函数
12.5 条件编译
12.5.1 ifdef-else-endif格式
12.5.2 ifndef-else-endif格式
12.5.3 if-else-endif格式
12.6 头文件的编写
12.7 小结
12.8 小测试

第2篇 C++的新特性
第13章 类
13.1 面向对象设计中的类机制
13.2 从结构到类的转变
13.2.1 成为过去的结构
13.2.2 面向对象的类
13.3 类的实例——对象
13.3.1 类与对象关系
13.3.2 对象的声明
13.3.3 对象成员的访问
13.4 类的数据成员
13.5 类的成员函数
13.5.1 成员函数的声明
13.5.2 成员函数的实现
13.5.3 成员函数的重载
13.5.4 给成员函数的参数设置默认值
13.6 类对成员的访问控制
13.6.1 成员控制的优点
13.6.2 各种控制关键字
13.6.3 public关键字
13.6.4 private关键字
13.7 小结
13.8 小测试

第14章 类中特殊的函数与常类型
14.1 对象的创造者——构造函数
14.1.1 默认的构造函数
14.1.2 带参数的构造函数
14.1.3 带默认参数的构造函数
14.1.4 对象“克隆”——拷贝构造函数
14.2 对象的毁灭者——析构函数
14.3 类中的常类型
14.3.1 常对象
14.3.2 常成员函数
14.3.3 常数据成员
14.4 小结
14.5 小测试

第15章 类与对象的各种指针和引用
15.1 对象与函数
15.1.1 对象指针作为函数的参数
15.2.2 对象引用作为函数的参数
15.3 一串连续的对象——对象数组
15.4 子对象与堆对象
15.4.1 子对象
15.4.2 堆对象
15.4.3 学习删除堆对象并综合练习堆对象的创建、删除
15.5 小结
15.6 小测试

第16章 共有结点、友元与操作符
16.1 类中的共有结点
16.1.1 静态数据成员
16.1.2 静态成员函数
16.2 This指针
16.3 友元函数与友元类
16.3.1 友元函数
16.3.2 友元类
16.4 多功能的操作符
16.5 文件输入输出对象的使用
16.5.1 文件的打开与关闭
16.5.2 写入数据到文件
16.5.3 读取文件数据
16.6 小结
16.7 小测试

第17章 父子关系——继承
17.1 父与子——继承
17.1.1 子承父业——继承的概念
17.1.2 继承的意义
17.2 单继承的实现
17.2.1 子类的声明
17.2.2 子类的继承方式和存取权限
17.3 子类的构造与析构函数及类型适应
17.3.1 子类的构造函数
17.3.2 子类的析构函数
17.3.3 子类的类型适应
17.4 多继承
17.4.1 海纳百川——多继承的概念
17.4.2 多继承的构造函数
17.4.3 多继承的问题
17.5 虚基类
17.5.1 虚基类的声明
17.5.2 虚基类的构造函数
17.6 小结
17.7 小测试