易学C++

第一篇　过程化的程序设计
第1章　良好的学习开端　1
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
第19章　万用的模板　285
19.1　函数模板　285
19.1.1　声明与定义函数模板　285
19.1.2　函数模板与重载　286
19.2　类模板　287
19.2.1　类模板的声明和定义　288
19.2.2　链表类模板实例　288
19.3　方法技巧　293
19.4　习题　293
第20章　异常的处理　297
20.1　亡羊也要补牢——程序出错处理　297
20.2　处理异常　298
20.2.1　尽力尝试——try语句　299
20.2.2　抓住异常——catch语句　299
20.3　抛出异常——throw语句　301
20.4　方法指导　302
20.5　习题　302
附录A　常用保留字列表　305
附录B　常见编译错误和解决方法　307
附录C　参考答案　310
第2章　310
第3章　310
第4章　311
第5章　315
第6章　319
第7章　322
第8章　326
第9章　328
第10章　331
第11章　332
第12章　333
第13章　336
第14章　337
第15章　338
第16章　341
第17章　349
第18章　351
第19章　353
第20章　355
附录D　参考文献　356