21天学通C++ 第3版PDF电子书下载

第一篇 1

第一章 开始 3

1.1 引言 3

1.2 C++历史简介 3

1.3 程序 4

1.4 本书要解决的问题 4

1.4.1 过程编程、结构化编程和面向对象编程 5

1.4.2 C++和面向对象编程 6

1.5 C++的发展历程 7

1.6 学习C++应该先学C吗 7

1.7 C++和Java 7

1.8 ANSI标准 8

1.9 准备编程 8

1.10 开发环境 9

1.11 编译源代码 9

1.13 程序开发周期 10

1.14 HELLO.cpp——你的第一个C++程序 10

1.12 用链接器生成可执行文件 10

1.15 开始学习Visual C++ 6.0 13

1.16 编译错误 13

1.17 小结 14

1.18 问与答 14

1.19 习题 15

1.19.1 测验 15

1.19.2 练习 15

2.1 一个简单程序 17

第二章 C++程序的组成部分 17

2.2 cout简介 19

2.3 注释 20

2.3.1 注释的类型 21

2.3.2 使用注释 21

2.3.3 对注释的忠告 22

2.4 函数 22

2.4.1 函数的使用 23

2.7 习题 25

2.6 问与答 25

2.5 小结 25

2.7.1 测验 26

2.7.2 练习 26

第三章 变量与常量 27

3.1 什么是变量 27

3.1.1 留出内存 27

3.1.2 整型量的大小 28

3.1.3 有符号和无符号 29

3.1.4 基本变量类型 29

3.2 定义一个变量 30

3.2.1 大小写敏感性 31

3.2.2 关键字 32

3.3 一次创建多个变量 32

3.4 给变量赋值 33

3.5 typedef 34

3.6 short与long的使用 35

3.6.2 有符号整型量的溢出 36

3.6.1 无符号整型量的溢出 36

3.7 字符型变量 37

3.7.1 字符和数字 38

3.7.2 特殊打印字符 38

3.8 常量 39

3.8.1 字面常量 39

3.8.2 符号常量 39

3.9 枚举型常量 41

3.11 问与答 43

3.10 小结 43

3.12 习题 44

3.12.1 测验 44

3.12.2 练习 45

第四章 表达式和语句 47

4.1 语句 47

4.1.1 空白 47

4.1.2 块和复合语句 48

4.2 表达式 48

4.3.1 赋值运算符 49

4.3 运算符 49

4.3.2 数学运算符 50

4.3.3 整型量除法和取模 51

4.4 赋值运算符与数学运算符的组合 52

4.5 自加与自减 53

4.6 优先级 55

4.7 括号的嵌套 56

4.8 真值的本质 56

4.8.1 关系运算符 57

4.9 if语句 58

4.9.1 缩进样式 61

4.9.2 else 61

4.9.3 高级if语句 63

4.10 在嵌套的if语句中使用大括号 65

4.11 逻辑运算符 67

4.12 简化求值 68

4.11.3 逻辑“非” 68

4.11.2 逻辑“或” 68

4.11.1 逻辑“与” 68

4.13 关系运算符的优先级 69

4.14 有关真假关系的进一步讨论 69

4.15 条件运算符（三目运算符） 70

4.16 小结 71

4.17 问与答 72

4.18 习题 72

4.18.1 测验 72

4.18.2 练习 73

第五章 函数 75

5.1 什么是函数 75

5.2 函数的返回值、参量和变元 75

5.3 声明和定义函数 76

5.3.1 函数的声明 76

5.3.2 函数原型 77

5.3.3 定义函数 79

5.4 函数的执行 80

5.5 局部变量 80

5.6 全局变量 83

5.7 使用全局变量的注意事项 84

5.8 有关局部变量的更多知识 84

5.9 函数语句 86

5.10 有关函数变元的更多知识 86

5.10.1 使用函数作为函数的参量 86

5.11 参量作为局部变量 87

5.12 有关返回值的更多知识 88

5.13 默认参量 90

5.14 函数重载 92

5.15 有关函数的一些专门话题 95

5.15.1 内嵌函数 96

5.15.2 递归 97

5.16 函数是如何工作的 101

5.16.1 抽象层次 101

5.16.2 划分RAM 102

5.16.3 堆栈与函数 104

5.18 问与答 105

5.17 小结 105

5.19 习题 106

5.19.1 测验 106

5.19.2 练习 106

第六章 基本类 109

6.1 创建新类型 109

6.1.1 为什么要创建新类型 110

6.2 类和成员 110

6.2.1 声明一个类 110

6.2.3 定义一个对象 111

6.2.2 有关命名习惯的一点说明 111

6.2.4 类与对象 112

6.3 访问类成员 112

6.3.1 给对象赋值而不是给类赋值 112

6.3.2 如果你不声明它，你的类就没有它 113

6.4 私有和公有 113

6.4.1 使成员数据私有 115

6.4.2 私有性与安全性 116

6.5 实现类的方法 118

6.6 构造函数和析构函数 120

6.6.2 使用默认构造函数 121

6.6.1 默认的构造函数和析构函数 121

6.7 成员函数const 124

6.8 界面与实现 125

6.9 在何处放置类声明和方法定义 128

6.10 内嵌实现 129

6.11 用其他类作为成员数据的类 131

6.12 结构体 135

6.12.1 为什么两个关键字做同一件事 135

6.13 小结 136

6.14 问与答 136

6.15 习题 137

6.15.1 测验 137

6.15.2 练习 137

7.1 循环 139

7.1.1 循环语句的起源——goto语句 139

第七章 程序流程 139

7.1.2 为什么现在不再使用goto语句 140

7.2 while循环 141

7.2.1 复杂的while语句 142

7.2.2 continue和break 144

7.2.3 while（true）循环 146

7.3 do...while循环 147

7.4 Do？while 148

7.5 for循环 150

7.5.1 高级for循环 152

7.5.2 多重初始化和自增运算 152

7.5.3 在for循环中使用空语句 153

7.5.4 空for循环 155

7.5.5 嵌套循环 156

7.5.6 for循环的作用域 157

7.6 循环总结 158

7.7 switch语句 160

7.7.1 使用带有菜单的switch语句 163

7.9 问和答 167

7.8 小结 167

7.10 习题 168

7.10.1 测验 168

7.10.2 练习 168

第一篇内容回顾 171

第二篇 177

第八章 指针 179

8.1 什么是指针 179

8.1.1 在指针中存储地址 181

8.1.2 指针名 183

8.1.3 间接引用运算符 183

8.1.4 指针、地址和变量 184

8.1.5 使用指针操作数据 184

8.1.6 检查地址 185

8.2 为什么要使用指针 187

8.3 栈和自由存储区 188

8.3.1 new 189

8.3.2 delete 189

8.4 内存泄漏 191

8.6 删除对象 192

8.5 在自由存储区内创建对象 192

8.7 访问数据成员 193

8.8 自由存储区中的成员数据 195

8.9 this指针 197

8.10 迷途指针、失控指针或悬浮指针 199

8.11 const指针 202

8.11.1 const指针和const成员函数 202

8.12 指针算法 204

8.11.2 const this指针 204

8.13 小结 207

8.14 问与答 207

8.15 习题 208

8.15.1 测验 208

8.15.2 练习 208

第九章 引用 211

9.1 什么是引用 211

9.2 对引用使用取址运算符 212

9.2.1 引用不能被重新赋值 214

9.3 什么可以被引用 215

9.4 空指针和空引用 217

9.5 通过引用传递函数参数 217

9.5.1 用指针使swap（）工作 219

9.5.2 使用引用实现swap（） 220

9.6 理解函数头文件和原型 222

9.7 返回多个值 222

9.8 使用引用传递来提高效率 225

9.8.1 传递const指针 228

9.8.2 使用引用代替指针 231

9.9 何时使用引用以及何时使用指针 233

9.10 混合使用引用和指针 234

9.11 不要返回对不在作用域中的对象的引用 235

9.12 返回对一个在堆中的对象的引用 237

9.13 指针的传递 239

9.15 问与答 240

9.16 习题 240

9.14 小结 240

9.16.1 测验 241

9.16.2 练习 241

第十章 高级函数 243

10.1 重载成员函数 243

10.2 使用默认值 245

10.3 默认值和重载函数的选择 248

10.4 默认构造函数 248

10.5 重载构造函数 249

10.6 初始化对象 250

10.7 复制构造函数 251

10.8 运算符重载 255

10.8.1 写一个自加函数 257

10.8.2 重载前置运算符 258

10.8.3 重载运算符函数的返回类型 259

10.8.4 返回无名临时对象 261

10.8.5 使用this指针 263

10.8.6 重载后置运算符 264

10.8.7 前置和后置之间的区别 264

10.8.8 加法运算符 267

10.8.9 重载operator+ 268

10.8.10 运算符重载中存在的问题 270

10.8.11 运算符重载的局限性 271

10.8.12 重载什么 271

10.8.13 赋值运算符 271

10.9 转换运算符 274

10.9.1 转换运算符 277

10.10 小结 278

10.12 习题 279

10.11 问与答 279

10.12.1 测验 280

10.12.2 练习 280

第十一章 继承 283

11.1 什么是继承 283

11.1.1 继承和派生 283

11.1.2 动物世界 285

11.1.3 派生的语法 285

11.2 私有型与保护型 287

11.3 构造函数和析构函数 289

11.3.1 向基构造函数传递参数 292

11.4 覆盖函数 296

11.4.1 隐藏基类方法 298

11.4.2 调用基函数 300

11.5 虚函数 302

11.5.1 虚函数是怎样工作的 306

11.5.3 切片（slicing） 307

11.5.2 不能从基类中访问派生类中的函数 307

11.5.4 虚析构函数 310

11.5.5 虚复制构造函数 310

11.5.6 虚函数的代价 313

11.6 小结 314

11.7 问与答 314

11.8 习题 315

11.8.1 测验 315

11.8.2 练习 316

12.1 什么是数组 317

第十二章 数组和链表 317

12.2 数组元素 318

12.3 超过数组未尾写入数据 319

12.4 篱笆标志错误 322

12.5 初始化数组 322

12.6 声明数组 323

12.7 对象的数组 324

12.8 多维数组 326

12.9 初始化多维数组 327

12.10 有关内存的一些话题 328

12.11 指针数组 329

12.12 在自由存储区声明数组 330

12.13 指向数组的指针和指针数组 331

12.14 指针与数组名 331

12.15 删除自由存储区中的数组 333

12.16 char数组 334

12.17 strcpy（）和strncpy（） 336

12.18 字符串类 337

12.19 链表和其他结构 344

12.20 链表案例研究 345

12.21 组件部分 346

12.22 你学到了什么 354

12.23 数组类 355

12.24 小结 355

12.25 问与答 356

12.26 习题 356

12.26.1 测验 356

12.26.2 练习 357

第十三章 多态性 359

13.1 单一继承的问题 359

13.1.1 升迁 361

13.1.2 下降 362

13.1.3 添加到两个链表 364

13.2 多重继承 365

13.2.1 多重继承对象的构成 368

13.2.2 多重继承对象中的构造函数 369

13.2.4 从共享基类中继承 372

13.2.3 歧义解析 372

13.2.5 虚继承 376

13.2.6 多重继承中存在的问题 380

13.2.7 混合继承和功能类 381

13.3 抽象数据类型 381

13.3.1 纯虚函数 385

13.3.2 实现纯虚函数 386

13.3.3 复杂的抽象层次 390

13.3.4 哪些类型是抽象的 394

13.4 观察者模式 395

13.4.1 有关多重继承、抽象数据类型和Java的一些情况 395

13.5 小结 396

13.6 问与答 396

13.7 习题 397

13.7.1 测验 397

13.7.2 练习 397

14.1 静态成员数据 399

第十四章 特殊类和函数 399

14.2 静态成员函数 405

14.3 函数指针 407

14.3.1 为什么使用函数指针 410

14.3.2 函数指针数组 414

14.3.3 把函数指针传递给其他函数 416

14.3.4 在函数指针中使用typedef 419

14.4 成员函数指针 422

14.4.1 成员函数指针数组 424

14.5 小结 427

14.6 问与答 427

14.7 习题 428

14.7.1 测验 428

14.7.2 练习 428

第二篇内容回顾 429

第三篇 441

第十五章 高级继承 443

15.1 包容 443

15.1.2 过滤对被包容成员的访问 450

15.1.1 访问被包容类的成员 450

15.1.3 包容的代价 451

15.1.4 按值来复制 454

15.2 继承实现/包容与代理 458

15.2.1 授权 459

15.3 私有继承 468

15.4 友元类 478

15.6 友元函数和运算符重载 488

15.5 友元函数 488

15.7 重载插入运算符 494

15.8 小结 498

15.9 问与答 499

15.10 习题 499

15.10.1 测验 499

15.10.2 练习 500

第十六章 流 503

16.1 流概述 503

16.1.1 封装 503

16.1.2 缓冲 504

16.2 流和缓冲区 506

16.3 标准I/O对象 506

16.4 重定向 507

16.5 用cin输入 507

16.5.1 串 509

16.5.2 串存在的问题 509

16.5.3 运算符>>返回对一个istream对象的引用 512

16.6.2 不使用参数的get（） 513

16.6.1 单字符输入 513

16.6 cin的其他成员函数 513

16.6.3 使用带字符引用参数的get（） 514

16.6.4 从标准输入读取字符串 515

16.6.5 使用cin.ignore（） 518

16.6.6 peek（）和putback（） 519

16.7 使用cout输出 520

16.7.1 清除输出 520

16.8 相关函数 521

16.9.1 使用cout.width（） 522

16.9 控制符、标志和格式化指令 522

16.9.2 设置填充字符 523

16.9.3 设置标志 524

16.10 流和printf（）函数 526

16.11 文件的输入和输出 529

16.12 ofstream 530

16.12.1 条件状态 530

16.12.2 打开文件进行输入和输出 530

16.12.3 在打开时改变ofstream的默认行为 532

16.13 二进制文件和文本文件 534

16.14 命令行处理 536

16.15 小结 540

16.16 问与答 540

16.17 习题 541

16.17.1 测验 541

16.17.2 练习 541

第十七章 名字空间 543

17.1 开始 543

17.2 按名字解析函数和类 544

17.3 创建名字空间 547

17.3.1 声明和定义类型 547

17.3.2 在名字空间外定义函数 548

17.3.3 添加新成员 549

17.3.4 嵌套的名字空间 549

17.4 使用名字空间 550

17.5 关键字using 552

17.5.1 using命令 552

17.5.2 using声明 554

17.6 名字空间别名 555

17.7 未命名的名字空间 556

17.8 标准名字空间std 557

17.9 小结 558

17.10 问与答 559

17.10.1 测验 559

17.10.2 练习 559

18.1 C++是面向对象的吗 561

第十八章 面向对象的分析及设计 561

18.2 构造模型 562

18.3 软件设计：建模语言 562

18.4 软件设计：过程 563

18.5 概览 565

18.6 需求分析 565

18.6.1 使用情况 566

18.6.2 应用分析 574

18.6.3 系统分析 574

18.6.4 计划文档 574

18.6.5 可视化 575

18.6.6 人工制品 575

18.7 设计 576

18.7.1 什么是类 576

18.7.2 变换 577

18.7.3 静态模型 579

18.7.4 动态模型 585

18.8 小结 589

18.9 问与答 590

18.10 习题 590

18.10.1 测验 590

18.10.2 练习 591

第十九章 模板 593

19.1 什么是模板 593

19.2 参数化类型 593

19.3 模板定义 594

19.2.1 实例化一个模板的实例 594

19.3.1 使用名字 596

19.3.2 模板的实现 596

19.4 模板函数 600

19.5 模板和友元 600

19.5.1 非模板友元类和函数 600

19.5.2 通用模板友元类或函数 605

19.6 使用模板单元 609

19.6.1 特殊化函数 613

19.6.2 静态成员和模板 619

19.8 容器 624

19.9 顺序容器 624

19.7 标准模板库 624

19.9.1 向量容器 625

19.9.2 列表容器 631

19.9.3 Deque容器 632

19.10 堆栈 633

19.11 了解队列 633

19.12.1 映射容器 634

19.12 了解关联容器 634

19.12.2 其他关联容器 637

19.13 算法类 638

19.13.1 不变序列运算 639

19.13.2 改变序列算法 640

19.14 小结 641

19.15 问与答 641

19.16.2 练习 642

19.16.1 测验 642

19.16 习题 642

第二十章 异常和错误处理 645

20.1 程序中的各种错误（bugs，errors，mistakes和code rot） 645

20.1.1 异常 646

20.1.2 关于代码腐烂 646

20.2 异常 647

20.2.1 如何使用异常 647

20.3.1 捕捉异常 652

20.3 使用try块和catch块 652

20.3.2 设置多条catch语句 653

20.3.3 异常等级 656

20.4 异常中的数据和命名异常对象 659

20.5 异常和模板 667

20.6 没有错误的异常 671

20.7 错误和调试 671

20.8 小结 672

20.7.3 检查内存 672

20.7.4 汇编器 672

20.7.1 断点 672

20.7.2 观察点 672

20.9 问与答 673

20.10 习题 673

20.10.1 测验 674

20.10.2 练习 674

21.1 预处理器和编译器 677

21.2 查看中间结果 677

第二十一章 进一步掌握的内容 677

21.3 使用#define 678

21.3.1 用#define替换常量 678

21.3.2 用#define进行测试 678

21.3，3 预编译命令#else 679

21.4 包含和包含警卫 680

21.5 宏函数 681

21.5.1 为什么总要用括号 682

21.5.2 宏与函数和模板 683

21.6 内联函数 684

21.7 字符串操作 685

21.7.1 字符串化 685

21.7.2 连结字符串 686

21.8 预定义宏 686

21.9 assert（） 687

21.9.1 用assert（）调试 688

21.9.2 assert（）与异常 688

21.9.4 类不变量 689

21.9.3 副作用 689

21.9.5 打印中间值 695

21.9.6 调试级别 696

21.10 位操作 703

21.10.1 “与”运算符 704

21.10.2 “或”运行符 704

21.10.3 “异或”运算符 704

21.10.4 求补运算符 704

21.10.5 设置位 704

21.10.7 反转位 705

21.10.6 清除位 705

21.10.8 位域 706

21.11 风格 709

21.11.1 缩进 709

21.11.2 大括号 709

21.11.3 长代码行 709

21.11.4 switch语句 710

21.11.5 程序文本 710

21.11.7 名字的拼写和大写 711

21.11.6 标识符名称 711

21.11.8 注释 712

21.11.9 访问 712

21.11.10 类定义 713

21.11.11 包含文件 713

21.11.12 assert（） 713

21.11.13 const 713

21.12 下一步 713

21.13 小结 714

21.12.3 保持联系 714

21.12.2 杂志 714

21.12.1 从何处获得帮助和建议 714

21.14 问与答 715

21.14.1 测验 716

21.14.2 练习 716

第三篇内容回顾 717

附录A 运算符的优先级 731

附录B C++关键字 733

C.1其他进制 735

附录C 二进制和十六进制 735

C.2 进制的转换 736

C.2.1二进制 737

C.2.2 为什么用二进制 738

C.2.3 位、字节和半字节 738

C.2.4 什么是KB（千字节） 738

C.2.5 二进制数 739

C.3 十六进制 739

附录D 答案 743