易学C++PDF电子书下载

第一篇 过程化的程序设计 1

第1章 良好的学习开端 1

1.1 软件与程序 1

1.2 程序设计要做什么 1

1.3 选好一种语言 2

1.4 C＋＋能够做些什么 2

1.5 C语言、C＋＋和VisualC＋＋的关系 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

第二篇　实战程序设计 119

第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

第三篇 面向对象的程序设计 163

第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