零起点学通C++ 多媒体范例教学PDF电子书下载

第1篇　初级篇 4

第1章　初识C＋＋ 4

1.1 C＋＋简介 4

1.2 C＋＋与C的区别 5

1.3 学习C＋＋之前需要先学C吗 6

1.4　C＋＋与其他语言的区别 6

1.5　C＋＋的版本以及安装问题 6

第2章　做一个最简短的C＋＋程序 7

2.1 简单的屏幕输出小程序 7

2.2　输出语句的使用 8

2.3　std∷介绍 9

2.4　iostream与iostream.h的区别 10

2.5　重名问题 11

2.6　注释 13

2.7　总结 13

第3章　初步了解函数 14

3.1 一个简单的函数 14

3.2　函数的传参 15

3.3 函数的返回值、参数与变量 16

3.4　函数的声明与定义 17

3.5 局部变量 19

3.6　全局变量 20

3.7　总结 21

第4章　C＋＋数据类型 22

4.1　变量的定义 22

4.2　将变量及数据存储在内存中 23

4.3　布尔型变量 24

4.4　字符型变量 25

4.5　wchar t双字符型变量 28

4.6　整型概述 29

4.7　整型变量的定义 31

4.8　浮点型变量 33

4.9　常量 33

4.10　枚举型常量 34

第5章　if语句与运算符 36

5.1　语句的定义 36

5.2　块的定义 36

5.3　表达式的定义 37

5.4　运算符的定义 38

5.4.1 赋值运算符的定义 38

5.4.2　数学运算符的定义 38

5.4.3 赋值运算符与数学运算符的联合 39

5.5 自加与自减 39

5.5.1　前置 40

5.5.2 后置 40

5.6　表达式的优先级 41

5.7　关系运算符 41

5.8　if语句 42

5.8.1 else语句 43

5.8.2　else if语句 44

5.8.3　if语句的嵌套 45

5.9　逻辑运算符及其使用 48

5.9.1 逻辑“与” 49

5.9.2　逻辑“或” 49

5.9.3　逻辑“非” 50

5.9.4　逻辑运算符的优先级 51

5.9.5　运算式的真假关系 53

5.10　三目运算符 54

5.10.1 三目运算符的优先问题 55

5.10.2　三目运算符的使用问题 56

5.10.3　三目运算符的型别问题 56

5.10.4　三目运算符在字符型变量中的应用 56

5.11　复杂嵌套的if语句 57

5.12　总结 58

第6章　面向对象 59

6.1　面向对象程序语言的主要特征 59

6.2　类、对象和成员 60

6.3　类、对象和成员的使用方法及区别 61

6.3.1 声明一个类 61

6.3.2 命名习惯 62

6.3.3　定义一个对象 62

6.3.4　类与对象的区别 62

6.3.5　对象与成员的关系 63

6.3.6　不要给类赋值 63

6.3.7　对象只能调用类中存在的方法 63

6.4　公有 65

6.5 私有 65

6.6　成员函数的声明和定义 68

6.7　内联函数 70

6.7.1　普通内联函数 70

6.7.2　内联成员函数 71

6.8　头文件与源文件 72

6.9　const成员函数 73

6.10　构造函数 74

6.11　默认构造函数 75

6.12　析构函数 76

6.13　析构对象数组 77

6.14　总结 78

第7章　循环语句 79

7.1　循环语句的前身——goto语句 79

7.2　慎用goto语句 80

7.3　while语句 80

7.3.1　带运算符的while语句 81

7.3.2 以字符为条件的while语句 81

7.3.3 限定while循环的次数 82

7.3.4　continue语句 83

7.3.5　break语句 84

7.3.6　永不休止的while循环 85

7.4　do...while循环 86

7.5　for循环 87

7.5.1　灵活的for循环 89

7.5.2　条件为空的for循环 89

7.5.3　执行为空的for循环 90

7.5.4　嵌套的for循环 91

7.6　switch语句 92

7.6.1　switch语句常见错误 94

7.6.2　switch的菜单功能 95

7.7　总结 96

第8章　指针 97

8.1　什么是地址 97

8.2　用指针来保存地址 98

8.2.1 空指针 98

8.2.2　指针与变量类型 99

8.2.3　用指针来访问值 99

8.2.4　指针地址、指针保存的地址和该地址的值 100

8.2.5　指针对数值的操作 101

8.2.6　更换指针保存的地址 102

8.3　为什么使用指针 103

8.3.1 栈和堆 103

8.3.2　用指针创建堆中空间 107

8.3.3　用指针删除堆中空间 108

8.4　动态内存 110

8.4.1 内存泄漏 110

8.4.2　在堆中创建对象 110

8.4.3　在堆中删除对象 111

8.4.4　访问堆中的数据成员 112

8.4.5 在构造函数中开辟内存空间 113

8.4.6　对象在栈与堆中的不同 114

8.5　this指针 116

8.6　指针的常见错误 117

8.7　指针运算 118

8.7.1　指针的加减运算 119

8.7.2　指针的赋值运算 119

8.7.3　指针的相减运算 120

8.7.4　指针的比较运算 121

8.8　指针 121

8.8.1 常量指针 121

8.8.2　指向常量的指针 122

8.8.3　指向常量的常指针 123

8.9　总结 124

第9章　引用 125

9.1 什么是引用 125

9.1.1　引用的地址 126

9.1.2　引用就是别名常量 126

9.1.3　引用对象 127

9.1.4　空引用 128

9.2　函数的参数传递 128

9.2.1 按值传递 128

9.2.2　按址传递 129

9.2.3　按别名传递 130

9.2.4 让函数返回多个值 131

9.3　传递对象 134

9.3.1　按值来传递对象 134

9.3.2　利用指针来传递对象 136

9.3.3　利用const指针来传递对象 137

9.3.4　利用引用来传递对象 138

9.3.5　到底是使用引用还是指针 140

9.3.6　引用和指针可以一块用 142

9.4　引用应注意的问题 143

9.4.1 引用容易犯的错误 143

9.4.2　引用一个按值返回的堆中对象 146

9.4.3 引用一个按别名返回的堆中对象 148

9.4.4　在哪里创建，就在哪里释放 149

9.5 总结 150

第10章　深入函数 152

10.1 函数重载 152

10.1.1　普通函数的重载 152

10.1.2　成员函数的重载 153

10.2　函数的默认参数 154

10.3　重载构造函数 156

10.3.1 成员变量的赋值与初始化 156

10.3.2　成员变量的初始化与构造函数 157

10.3.3　复制构造函数 160

10.3.4　构造函数和new运算符 161

10.3.5　再谈默认构造函数 163

10.4　析构函数和delete运算符 164

10.4.1　默认析构函数 165

10.4.2　调用构造函数进行类型转换 165

10.5　浅层复制构造函数 166

10.6　深层复制构造函数 168

第11章　运算符重载 171

11.1　运算符重载 171

11.2　在成员函数中实现自加 172

11.3　重载前置自加运算符 172

11.4　创建临时对象 174

11.5　创建无名临时对象 175

11.6　取消创建临时对象 176

11.7　重载后置自加运算符 178

11.8　重载加法运算符函数operator＋ 179

11.9　重载赋值运算符函数operator＝ 181

11.10　转换类型运算符 188

11.10.1　温习调用构造函数实现的类型转换 188

11.10.2　通过构造函数将变量转换为一个对象的成员变量 189

11.10.3　通过operator关键字进行转换 190

11.11 什么可以重载，什么不可以重载 192

第12章　继承 193

12.1　什么是继承和派生 193

12.1.1　复杂的继承和派生 193

12.1.2　继承和派生如何在C＋＋中实现 194

12.1.3　继承的种类及语法 194

12.1.4　单一继承 195

12.2　公有型、保护型和私有型 197

12.3 访问权限 198

12.4　多重继承 203

12.5　继承的构造与析构 205

12.6　合理利用基类构造函数 209

12.7　继承和重载的两义性问题 212

12.7.1 多重继承容易产生两义性 212

12.7.2　继承中的重载 214

12.7.3　两义性的归属问题 217

12.7.4　减少两义性产生的混淆问题 218

12.7.5　虚基类不会产生两义性 220

12.8　总结 221

第13章　虚函数 223

13.1　指向子对象的父指针 223

13.2　虚函数 225

13.3　拳击游戏 227

13.4　继承是否可以实现多态性 229

13.5　在编译时的静态联编 231

13.6　在运行时的静态联编 231

13.7　在运行时的动态联编 232

13.8　在编译时的动态联编 235

13.9　调用虚函数 235

13.9.1　在虚函数中调用成员函数 235

13.9.2　3种调用虚函数的方式比较 237

13.10　被继承的虚函数仍然是虚函数 239

13.11 系统是如何调用虚函数的 241

13.12　在虚函数中使用成员名限定 241

13.13　虚析构函数 242

13.14　总结 244

第14章　数组 245

14.1　数组的基本用法 245

14.1.1　什么是数组 245

14.1.2　数组元素 246

14.1.3　数组下标越界 246

14.1.4　倒序输出 247

14.1.5 将数组的下标定义为常量 248

14.1.6　手动操作数组元素 248

14.1.7　数组的初始化 249

14.2　数组的用途 250

14.2.1　求平均考试成绩 250

14.2.2　兔子繁殖问题 252

14.2.3　数字排序问题 254

14.3　数组在内存中的分布 256

14.4　输出数组名 258

14.5　数组名与函数 258

14.6　传递与接收 259

14.7　数组与函数 260

14.7.1 函数传参实例一——求数组所有元素的和 261

14.7.2　函数传参实例二——用递增法查找数据 262

14.7.3 函数传参实例三——用二分算法查找数据 263

14.7.4　函数传参实例四——判断数组是否按照顺序排列 264

14.7.5 函数传参实例五——判断数组排列方式后执行不同的函数 265

14.8　数组在对象中的传参 266

14.9　对象数组 267

14.10　在对象数组中初始化成员变量 268

14.11 指针数组 270

14.12　枚举常量与数组 275

14.13 多维数组 276

14.14　多维数组的初始化 276

14.15　字符数组 278

14.16　重载数组下标操作符 287

14.17　总结 289

第15章　链表 290

15.1 明链表结构 290

15.2　简单的图书链表 291

15.2.1 图书链表 291

15.2.2　类的链表 292

15.3　动态链表 292

15.3.1　动态链表的建立 293

15.3.2　解决输入字符造成死循环的问题 295

15.3.3　动态链表的显示 299

15.3.4　动态链表的删除 299

15.3.5 动态链表的插入 301

15.3.6　链表统计 302

15.3.7　使用链表 303

15.4　完整的动态链表清单 306

15.5　链表使用案例——走迷宫 310

15.5.1　创建Windows应用程序项目 310

15.5.2　创建窗口 311

15.5.3　加载图片 313

15.5.4　句柄是什么 315

15.5.5　显示图片 315

15.5.6 动画 319

15.5.7　键盘控制人物移动 323

15.5.8　迷宫墙壁 327

15.5.9　走迷宫 333

15.5.10　用链表记录行走路线 336

第16章　多态性 341

16.1　为什么要使用多重继承 341

16.2　在派生类中增加函数 343

16.3　使用多重继承 345

16.4　多重继承的初始化 347

16.5　多个子基类共享一个父基类 349

16.6　虚基类 352

16.7　慎用多重继承 356

16.8　空的虚函数 356

16.9　模拟抽象类 358

16.10　纯虚函数与抽象类 360

16.11　复杂的抽象结构 363

16.12　总结 366

第17章　类的特殊成员 367

17.1　静态成员变量 367

17.2　私有静态成员变量 370

17.3　静态成员函数 370

17.4　静态成员的使用 372

17.5 函数指针 374

17.6　函数指针数组 378

17.7　函数指针作为函数的参数 379

17.8　利用typedef简化函数指针 381

17.9　类的函数指针 383

17.10　成员函数指针数组 385

第18章　字符串 388

18.1　char型字符串 388

18.2　string型字符串 391

18.2.1　string型字符串的赋值 396

18.2.2　string型字符串的合并 398

18.2.3　string型字符串的部分合并 400

18.2.4　string型字符串的替换 401

18.2.5　string型字符串的复制 404

18.2.6　string型字符串的插入 405

18.2.7　string型字符串的删除 406

18.2.8　string型字符串的查找 407

18.2.9　string型字符串的比较 408

18.2.10　判断string型字符串是否为空 409

18.3　字符串的使用 410

18.3.1 交换两个字符串的内容 410

18.3.2　将string型字符串转为char型字符串 411

18.3.3　char型字符串与函数 411

18.3.4 函数如何返回字符串 413

18.4　结构体 414

18.4.1　结构体的赋值 418

18.4.2　结构体与函数 418

18.4.3 结构体与string 421

18.5　string数组与函数 422

18.6　流的使用 423

18.6.1　重载输出运算符＜＜ 424

18.6.2　用友元的方式重载输出运算符 426

18.6.3　重载自加运算符的执行次序 426

18.6.4　重载输入运算符＞＞ 428

18.7　编写一个String类 429

18.7.1　创建String类 429

18.7.2　创建可自动调节大小的String类字符串对象 430

18.7.3　限制数组越界 432

18.7.4　用复制构造函数实现字符串的初始化功能 434

18.7.5　用重载赋值运算符函数实现字符串赋值功能 439

18.7.6　用重载输出运算符函数operator＜＜（）实现字符串的输出 442

18.7.7　用重载输入运算符函数operator＞＞（）实现字符串的输入 444

18.7.8　用重载比较运算符实现字符串的比较 446

18.7.9 为String类添加字符串的相加功能 450

18.7.10　为String类添加字符串的＋＝功能 455

18.7.11 完成后的String类 459

第2篇　高级篇 467

第19章　代码重用 467

19.1 包含 467

19.2　将String类作为包含类 469

19.3　为book类重载执行相加运算的成员函数 473

19.4　包含对系统造成的消耗 477

19.5　按别名传递book对象 481

19.6　包含指向另一个类的指针 484

19.6.1　数据类Data 484

19.6.2　链表类Node 485

19.6.3　标签类Label 485

19.6.4　头节点类HeadNode 486

19.6.5　尾节点类TailNode 487

19.6.6　中间节点类InterNode 488

19.6.7　InterNode类的构造函数 489

19.6.8　InterNode类的插入函数 489

19.6.9　全部程序 491

19.7　将头节点、中间节点和尾节点合并为一个节点 498

19.7.1　数据类Data 498

19.7.2 由Data类派生的图书类Book 498

19.7.3 由Data类派生的药品类Drug 499

19.7.4　创建一个节点类Node 499

19.7.5　用来操作节点类Node的List类 500

19.7.6　List类的GetFirst（）方法 501

19.7.7　List类的operator［］方法 501

19.7.8 List类的Show（）方法 502

19.7.9　List类的Insert（）方法 502

19.7.10　List类的Delete（）方法 504

19.7.11 List类的Find（）方法 506

19.7.12　商品管理全部程序 507

19.8　利用类的包含来实现代码重用 517

19.9　私有继承 526

19.10　什么时候使用私有继承，什么时候使用包含 534

19.11 保护继承 535

19.12　公有继承、私有继承和保护继承的不同 535

19.13 总结 543

第20章　友元类与嵌套类 545

20.1 友元类 545

20.2　嵌套类 553

第21章　流 557

21.1 流的操作 557

21.1.1 缓冲 557

21.1.2　流和缓冲区 557

21.1.3　标准输入／输出对象 558

21.1.4　重定向 558

21.1.5　对象代表流 558

21.2　用cout输出 559

21.2.1 重载运算符operator＜＜ 559

21.2.2　清理缓冲区 562

21.2.3 有关输出的相关函数 563

21.2.4　设置输出的字段宽度 564

21.2.5　设置填充字段 565

21.2.6　设置浮点数的显示精度 566

21.2.7　输出末尾的0 567

21.2.8　设置标志 567

21.2.9　setf（）函数原型 573

21.2.10　所有15个标志以及3个指示标志 575

21.2.11 unset（）函数 576

21.2.12　标准控制符 577

21.2.13　iomanip头文件与标准控制符 579

21.3　用cin输入 581

21.3.1　字符串的输入 582

21.3.2　字符串的输入问题 583

21.3.3　get（）函数 583

21.3.4　带字符引用参数的get（）函数 590

21.3.5　带2个参数的get（）函数 591

21.3.6　带3个参数get（）函数 593

21.3.7　getline（）函数 596

21.3.8　read（）函数 598

21.3.9　gcount（）函数 600

21.3.10　peek（）函数 601

21.3.11　putback（）函数 602

21.4　文件的输入和输出 603

21.4.1　输出数据到文件 603

21.4.2　读取文件中的数据 604

21.4.3　读取空格及空格后面的字符 605

21.5　多种打开文件的方式 607

21.6　检查文件是否打开 609

21.7　二进制文件和文本文件 613

21.7.1 以文本形式输出到文件 614

21.7.2 以二进制形式输出到文件 615

21.8　打开多个文件 616

21.9　命令行处理文件 616

21.10　使用命令行处理文件 619

21.11　指定读取文件中的数据 621

21.12　输出数据到文件指定位置处 623

21.13　seekp（）和seekg（）函数的结合使用 624

21.14　临时文件 634

21.15　sstream字符串输入／输出流类 635

21.15.1　字符串输入流类istringstream 636

21.15.2　字符串输出流类ostringstream 638

21.15.3　字符串输入／输出流类stringstream 640

21.15.4　综合实例——十进制转十六进制 642

21.16　具有保存和读取功能的商品管理系统 644

21.16.1　将节点中的数据保存到文件 644

21.16.2　读取文件中的数据并创建节点 648

21.16.3　完整的商品管理系统 649

第22章　命名空间 660

22.1 什么是命名空间 660

22.2　创建命名空间 663

22.2.1 扩充命名空间的内容 663

22.2.2　尽量在命名空间之外定义函数 663

22.2.3　命名空间中的成员都是公有的 665

22.3　使用命名空间 665

22.4　使用关键字using 668

22.5　为你的命名空间取个别名 671

22.6　未命名的命名空间 672

22.6.1 未命名空间与全局变量的区别 673

22.6.2　未命名空间与static的区别 673

22.6.3　未命名命名空间、static与extern的区别 674

22.7　标准命名空间std 675

第23章　模板 676

23.1　什么是模板 676

23.2 重载模板 679

23.3　具体化函数模板 681

23.3.1　函数模板不能重载 681

23.3.2　具体化函数模板解决重载问题 683

23.3.3　具体化函数模板与实例化模板函数 685

23.4　普通函数、函数模板与具体化函数模板的优先级 688

23.4.1 普通函数和函数模板的执行次序 688

23.4.2 函数模板与具体化函数模板的执行次序 689

23.4.3 具体化函数模板与普通函数的优先级 689

23.5　函数模板的匹配 690

23.6　类模板的定义 691

23.7　复杂类模板 693

23.8　数组模板 697

23.9 对象数组模板 701

23.10　具有多个参数的模板 705

23.11 为模板参数提供默认值 707

23.12　约束模板 708

23.13　嵌套类模板 710

23.14 将模板用作参数 711

23.15　模板和友元 714

23.15.1　非模板友元类或函数 714

23.15.2　通用模板友元类或函数 719

23.15.3 特定类型模板友元类或函数 722

23.16　多余的临时对象 727

23.17　静态成员和模板 735

23.18　标准模板库 735

23.18.1 容器 736

23.18.2　顺序容器 736

23.18.3 关联容器 755

23.18.4　算法类 773

23.18.5　学生成绩管理系统 809

23.18.6　总结 821

第24章　异常和错误处理 823

24.1 异常 823

24.2　设置多条catch语句 828

24.3　异常的派生 830

24.4　创建异常类的成员函数 832

24.5　异常类的虚函数 835

24.6　异常类与模板的关系 838

24.7　异常类与智能指针 841

24.8 为什么智能指针不能用于STL容器 844

24.9 通讯录 847

24.9.1 建立通讯录数据库 847

24.9.2　建立数据源 848

24.9.3　创建应用程序 850

24.9.4　设置应用程序的界面 852

24.9.5　添加、删除与修改 855

24.9.6 自动创建数据源 859

24.10　总结 865

第25章　补充知识 866

25.1　预处理过程 866

25.1.1　预处理指令 866

25.1.2　＃include指令 867

25.1.3　＃define指令 867

25.1.4　用＃define指令替换常量 867

25.1.5　用＃define定义一个特定字符串并对其进行测试 867

25.1.6　＃ifdef、＃define和＃endif的用途 869

25.1.7　带参数的＃define 869

25.1.8　宏与内联函数 871

25.1.9　＃运算符 872

25.1.10　＃＃运算符 872

25.1.11 ＃undef指令 874

25.1.12　＃if指令 874

25.1.13　＃endif指令 874

25.1.14　＃ifdefined指令 874

25.1.15　＃ifdef和＃ifndef指令 875

25.1.16　＃elif指令 875

25.1.17　＃error指令 875

25.1.18　＃line指令 876

25.1.19　＃pragma指令 876

25.2　预定义的宏 884

25.3　assert（）宏 885

25.4　尝试编写一个简的ASSERT（）宏 886

25.5　不能为0的变量 888

25.6 用宏函数来输出表达式的值 889

25.7　调试的级别 890

25.8　C＋＋类型转换及运行时类型信息（RTII） 892

25.8.1 动态类型转换符 892

25.8.2　静态类型转换 897

25.8.3　重新解释类型转换 899

25.8.4　常类型转换 900

25.8.5　运行时类型信息 901

25.9　关键字volatile 902

25.10　关键字const 904

25.11 关键字mutable 904

25.12 联合数据类型union 905

25.13　联合数据类型的内存占用 907

25.14　匿名联合体 908

25.15 再谈指针 909

25.15.1　指针与数组 909

25.15.2　通过指针操作多维数组 913

25.15.3　将指向多维数组的指针作为函数参数 915

25.15.4　指向字符串的指针 917

25.15.5　接收字符串地址的函数 918

25.15.6　指向字符串的指针与字符数组的区别 919

25.15.7　指向函数的指针 921

25.15.8　指向函数指针的用途 922

25.15.9　指针数组 925

25.15.10　指向指针的指针 926

25.16　位运算 927

25.16.1 按位与运算符＆ 928

25.16.2　按位或运算符｜ 931

25.16.3　异或运算符∧ 931

25.16.4　取反运算符～ 933

25.16.5 左移运算符＜＜ 934

25.16.6　右移运算符＞＞ 934

25.16.7　复合位运算符 935

25.16.8　不同长度数字的位运算 935

25.16.9　位运算的实例 935

25.17　位字段 936

25.18　区域差异 939

25.18.1　locale类 940

25.18.2　默认区域表示或全局区域表示 941

25.18.3　时间与地理设置 942

25.18.4　locale与 time.h中时间函数的搭配使用 961

25.1 8.5　区域表示locale与流的搭配使用 968

25.18.6　区域表示locale与模板的搭配使用 968

25.19　总结 970

附录A　ASCII码对照表 971

附录B　C＋＋的关键字 973

附录C　C＋＋常用头文件列表 975

附录D　运算符的优先级 977

后记 979