21天学通C++【2025|PDF|Epub|mobi|kindle电子书版本百度云盘下载】

21天学通C++PDF格式电子书版下载

注意：本站所有压缩包均有解压码： 点击下载压缩包解压工具

第一篇2

第一章 开始2

1.1 引言2

1.2 C++历史简介2

1.2.1 本书要解决的问题2

1.2.2 过程编程、结构化编程和面向对象的编程3

1.2.3 C++和面向对象编程4

1.3 C++的发展历程4

1.4 学习C++应该先学C吗5

1.5 C++和Java及C#5

1.6 ANSI标准5

1.7 准备编程5

1.8 开发环境6

1.9 生成程序6

1.9.1 用编译器生成对象文件6

1.9.2 用链接器生成可执行文件6

1.10 程序开发周期7

1.11 HELLO.cpp——你的第一个C++程序8

1.12 开始学习编译器9

1.12.1 创建Hello World项目9

1.13 编译错误9

1.14 小结10

1.15 问与答10

1.16 习题10

1.16.1 测验11

1.16.2 练习11

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

2.1 一个简单程序12

2.2 cout简介13

2.3 使用标准的Namespace15

2.4 注释17

2.4.1 注释的类型17

2.4.2 使用注释17

2.5 函数18

2.4.3 对注释的忠告18

2.5.1 函数的使用19

2.6 小结20

2.7 问与答20

2.8 习题21

2.8.1 测验21

2.8.2 练习21

3.1.1 将数据存储在内存中22

3.1.2 留出内存22

3.1 什么是变量22

第三章 变量与常量22

3.1.3 整型量的大小23

3.1.4 有符号和无符号24

3.1.5 基本变量类型24

3.2 定义一个变量25

3.2.1 大小写敏感性26

3.2.2 关键字26

3.4 给变量赋值27

3.3 一次创建多个变量27

3.5 typedef28

3.6 short与long的使用29

3.6.1 无符号整型量的回绕29

3.6.2 有符号整型量的回绕30

3.7 字符型变量31

3.7.1 字符和数字31

3.7.2 特殊打印字符32

3.8 常量32

3.8.2 符号常量33

3.8.1 字面常量33

3.9 枚举型常量34

3.10 小结35

3.11 问与答36

3.12 习题36

3.12.1 测验36

3.12.2 练习37

4.1.1 空白38

4.1.2 块和复合语句38

第四章 表达式和语句38

4.1 语句38

4.2 表达式39

4.3 运算符40

4.3.1 赋值运算符40

4.3.2 数学运算符40

4.3.3 整型量除法和取模41

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

4.5.1 前置和后置42

4.5 自加与自减42

4.6 优先级44

4.7 括号的嵌套44

4.8 真值的本质45

4.8.1 关系运算符45

4.9 if语句46

4.9.1 缩进样式48

4.9.2 else49

4.9.3 高级if语句50

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

4.11 逻辑运算符54

4.11.1 逻辑“与”54

4.11.2 逻辑“或”54

4.11.3 逻辑“非”54

4.12 简化求值55

4.13 关系运算符的优先级55

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

4.15 条件运算符(三目运算符)56

4.16 小结57

4.17 问与答57

4.18 习题58

4.18.1 测验58

4.18.2 练习58

第五章 函数60

5.1 什么是函数60

5.3.1 函数的声明61

5.3.2 函数原型61

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

5.3 声明和定义函数61

5.3.3 定义函数62

5.4 函数的执行63

5.5 局部变量63

5.5.1 作用范围65

5.6 全局变量65

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

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

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

5.9 函数语句67

5.10.1 使用函数作为函数的参数68

5.11 参数作为局部变量68

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

5.13 默认参数71

5.14 函数重载72

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

5.15.1 内嵌函数75

5.15.2 递归76

5.16.2 划分RAM80

5.16 函数是如何工作的80

5.16.1 抽象层次80

5.16.3 堆栈与函数81

5.17 小结82

5.18 问与答82

5.19 习题83

5.19.1 测验83

5.19.2 练习83

6.2 创建新类型85

6.1 C++是面向对象的吗85

第六章 面向对象编程85

6.2.1 为什么要创建新类型86

6.3 类和成员86

6.3.1 声明一个类86

6.3.2 有关命名习惯的一点说明87

6.3.3 定义一个对象87

6.3.4 类与对象87

6.4 访问类成员87

6.4.2 如果你不声明它，你的类就没有它88

6.5 私有和公有88

6.4.1 给对象赋值而不是给类赋值88

6.5.1 使成员数据私有90

6.5.2 私有性与安全性91

6.6 实现类的方法92

6.7 构造函数和析构函数94

6.7.1 默认的构造函数和析构函数95

6.7.2 使用默认构造函数95

6.8 成员函数const97

6.9 界面与实现98

6.10 在何处放置类声明和方法定义100

6.11 内嵌实现100

6.12 用其他类作为成员数据的类102

6.13 结构体105

6.13.1 为什么两个关键字做同一件事106

6.14 小结106

6.15 问与答106

6.16.1 测验107

6.16.2 练习107

6.16 习题107

第七章 程序流程109

7.1 循环109

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

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

7.2 while循环110

7.2.1 复杂的while语句111

7.2.2 continue和break112

7.2.3 while(true)循环114

7.3 do…while循环115

7.4 do…while116

7.5 for循环118

7.5.1 高级for循环119

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

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

7.5.4 空for循环122

7.5.5 嵌套循环123

7.5.6 for循环的作用域124

7.6 循环总结125

7.7 switch语句126

7.7 使用带有菜单的switch语句129

7.8 小结131

7.9 问与答131

7.10 习题132

7.10.1 测验132

7.10.2 练习132

第一篇内容回顾134

8.1 什么是指针140

第八章 指针140

第二篇140

8.1.1 在指针中存储地址141

8.1.2 指针名142

8.1.3 间接引用运算符142

8.1.4 指针、地址和变量143

8.1.5 使用指针操作数据144

8.1.6 检查地址145

8.2 为什么要使用指针146

8.3.1 new147

8.3 栈和自由存储区(堆)147

8.3.2 delete148

8.4 内存泄漏149

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

8.6 删除对象150

8.7 访问数据成员151

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

8.9 this指针155

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

8.11.1 const指针和const成员函数158

8.11 const指针158

8.11.2 const this指针160

8.12 指针算法高级主题160

8.13 小结162

8.14 问与答162

8.15 习题163

8.15.1 测验163

8.15.2 练习163

9.1 什么是引用165

第九章 引用165

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

9.2.1 引用不能被重新赋值167

9.3 什么可以被引用168

9.4 空指针和空引用170

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

9.5.1 用指针使swap()工作171

9.5.2 使用引用实现swap()172

9.7 返回多个值174

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

9.7.1 通过引用返回值175

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

9.8.1 传递const指针179

9.8.2 使用引用代替指针181

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

9.10 混合使用引用和指针183

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

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

9.13 指针的传递187

9.15 问与答188

9.16 习题188

9.16.1 测验188

9.16.2 练习188

9.14 小结188

第十章 高级函数190

10.1 重载成员函数190

10.2 使用默认值192

10.5 重载构造函数194

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

10.4 默认构造函数194

10.6 初始化对象196

10.7 复制构造函数196

10.8 运算符重载200

10.8.1 写一个自加函数200

10.8.2 重载前置运算符201

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

10.8.4 返回无名临时对象204

10.8.5 使用this指针205

10.8.6 重载后置运算符206

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

10.8.8 加法运算符208

10.8.9 重载operator+210

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

10.8.11 运算符重载的局限性211

10.8.12 重载什么211

10.8.13 赋值运算符212

10.9 处理数据类型转换214

10.9.1 转换运算符216

10.10 小结217

10.11 问与答217

10.12 习题218

10.12.1 测验218

10.12.2 练习218

11.1 构造模型220

11.2 软件设计：建模语言220

第十一章 面向对象的分析及设计220

11.3 软件设计：过程221

11.4 Extreme编程222

11.5 概览223

11.6 需求分析223

11.6.1 使用情况223

11.6.2 应用分析230

11.6.3 系统分析230

11.6.6 人工制品231

11.6.5 可视化231

11.6.4 计划文档231

11.7 设计232

11.7.1 什么是类232

11.7.2 变换233

11.7.3 静态模型234

11.7.4 动态模型240

11.8 小结242

11.9 问与答242

11.10.2 练习243

11.10 习题243

11.10.1 测验243

第十二章 继承244

12.1 什么是继承244

12.1.1 继承和派生244

12.1.2 动物世界245

12.1.3 派生的语法245

12.2 私有型与保护型247

12.3 构造函数和析构函数248

12.3.1 向基构函数传递参数250

12.4 覆盖函数254

12.4.1 隐藏基类方法255

12.4.2 调用基方法257

12.5 虚函数258

12.5.1 虚函数是怎样工作的261

12.5.2 不能从基类中访问派生类中的函数262

12.5.3 切片(slicing)262

12.5.4 虚析构函数264

12.5.5 虚复制构造函数265

12.5.6 虚函数的代价267

12.6 小结267

12.7 问与答268

12.8 习题268

12.8.1 测验268

12.8.2 练习269

13.2 数组元素270

13.1 什么是数组270

第十三章 数组和链表270

13.3 超过数组末尾写入数据271

13.4 篱笆标志错误274

13.5 初始化数组274

13.6 声明数组275

13.7 对象的数组276

13.8 多维数组277

13.9 初始化多维数组278

13.11 指针数组279

13.10 有关内存的一些话题279

13.12 在自由存储区声明数组281

13.13 指向数组的指针和指针数组281

13.14 指针与数组名281

13.15 删除自由存储区中的数组283

13.16 char数组283

13.17 strcpy()和stmcpy()285

13.18 字符串类286

13.19 链表和其他结构291

13.20 链表案例研究292

13.20.1 责任授权292

13.21 组件部分292

13.22 你学到了什么299

13.23 数组类299

13.24 小结300

13.25 问与答300

13.26 习题300

13.26.2 练习301

13.26.1 测验301

第十四章 多态性302

14.1 单一继承的问题302

14.1.1 升迁304

14.1.2 下降304

14.1.3 添加到两个链表306

14.2 多重继承306

14.2.1 多重继承对象的构成309

14.2.2 多重继承对象中的构造函数309

14.2.4 从共享基类中继承312

14.2.3 歧义解析312

14.2.5 虚继承315

14.2.6 多重继承中存在的问题318

14.2.7 混合继承和功能类319

14.3 抽象数据类型319

14.3.1 纯虚函数322

14.3.2 实现纯虚函数323

14.3.3 复杂的抽象层次326

14.5 问与答329

14.4 小结329

14.3.4 哪些类型是抽象的329

14.6 习题330

14.6.1 测验330

14.6.2 练习330

第二篇内容回顾331

第三篇340

第十五章 特殊类和函数340

15.1 静态成员数据340

15.2 静态成员函数344

15.3 函数指针346

15.3.1 为什么使用函数指针349

15.3.2 函数指针数组351

15.3.3 把函数指针传递给其他函数353

15.3.4 在函数指针中使用typedef356

15.4 成员函数指针358

15.4.1 成员函数指针数组360

15.5 小结361

15.7.2 练习362

15.7.1 测验362

15.6 问与答362

15.7 习题362

第十六章 高级继承364

16.1 包容364

16.1.1 访问被包容类的成员369

16.1.2 过滤对被包容成员的访问369

16.1.3 包容的代价370

16.1.4 按值来复制372

16.2 按继承/包容条款实现与代理375

16.2.1 授权376

16.3 私有继承383

16.4 友元类390

16.5 友元函数397

16.6 友元函数和运算符重载397

16.7 重载插入运算符401

16.10 习题405

16.9 问与答405

16.8 小结405

16.10.1 测验406

16.10.2 练习406

第十七章 流408

17.1 流概述408

17.1.1 封装408

17.1.2 缓冲409

17.3 标准I/O对象410

17.2 流和缓冲区410

17.4 重定向411

17.5 用cin输入411

17.5.1 串412

17.5.2 串存在的问题413

17.5.3 运算符>>返回对一个istream对象的引用415

17.6 cin的其他成员函数415

17.6.1 单字符输入415

17.6.2 不使用参数的get()415

17.6.4 从标准输入读取字符串417

17.6.3 使用带字符引用参数的get()417

17.6.5 使用cin.ignore()419

17.6.6 peek()和putback()421

17.7 使用cout输出421

17.7.1 清除输出422

17.8 相关函数422

17.9 控制符、标志和格式化指令423

17.9.1 使用cout.width()423

17.9.2 设置填充字符424

17.9.3 设置标志425

17.10 流和printf()函数426

17.11 文件的输入和输出429

17.12 ofstream429

17.12.1 条件状态429

17.12.2 打开文件进行输入和输出429

17.12.3 在打开时改变ofstream的默认行为430

17.13 二进制文件和文本文件432

17.14 命令行处理434

17.16 问与答437

17.15 小结437

17.17 习题438

17.17.1 测验438

17.17.2 练习438

第十八章 名字空间439

18.1 开始439

18.2 按名字解析函数和类439

18.3 创建名字空间442

18.3.1 声明和定义类型442

18.3.2 在名字空间外定义函数443

18.3.3 添加新成员443

18.3.4 嵌套的名字空间444

18.4 使用名字空间444

18.5 关键字using446

18.5.1 using命令446

18.5.2 using声明447

18.7 未命名的名字空间449

18.6 名字空间别名449

18.8 标准名字空间std450

18.9 小结451

18.10 问与答451

18.11 习题452

18.11.1 测验452

18.11.2 练习452

19.2.1 实例化一个模板的实现453

19.2 参数化类型453

19.1 什么是模板453

第十九章 模板453

19.3 模板定义454

19.3.1 使用名字455

19.3.2 模板的实现455

19.4 模板函数458

19.5 模板和友元459

19.5.1 非模板友元类和函数459

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

19.6 使用模板项465

19.6.1 特殊化函数469

19.6.2 静态成员和模板473

19.7 标准模板库477

19.8 容器477

19.9 了解顺序容器477

19.9.1 向量容器477

19.9.2 列表容器482

19.9.3 Deque容器483

19.10 堆栈483

19.12.1 映射容器484

19.11 了解队列484

19.12 了解关联容器484

19.12.2 其他关联容器487

19.13 算法类487

19.13.1 不变序列运算488

19.13.2 改变序列算法488

19.14 小结489

19.15 问与答489

19.16.2 练习490

19.16.1 测验490

19.16 习题490

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

20.1 程序中的各种错误(bugs、errors、mistakes和code rot)492

20.1.1 异常492

20.2 异常493

20.2.1 如何使用异常493

20.3 使用try块和catch块497

20.3.1 捕捉异常497

20.3.2 设置多条catch语句498

20.3.3 异常等级500

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

20.5 异常和模板508

20.6 没有错误的异常511

20.7 关于代码腐烂511

20.8 错误和调试511

20.10 问与答512

20.9 小结512

20.8.4 汇编512

20.8.3 检查内存512

20.8.1 断点512

20.8.2 观察点512

20.11 习题513

20.11.1 测验513

20.11.2 练习513

21.2 查看中间结果515

21.3 使用#define515

21.1 预处理器和编译器515

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

21.3.1 用#define替换常量516

21.3.2 用#define进行测试516

21.3.3 预编译命令#else516

21.4 包含和包含警卫517

21.5 宏函数518

21.5.1 为什么总要用括号519

21.5.2 宏与函数和模板520

21.6 内联函数520

21.7.2 连结字符串522

21.7 字符串操作522

21.7.1 字符串化522

21.8 预定义宏523

21.9 assert()523

21.9.1 用assert()调试524

21.9.2 assert()与异常524

21.9.3 副作用525

21.9.4 类不变量525

21.9.5 打印中间值529

21.9.6 调试级别530

21.10 位操作535

21.10.1 “与”运算符536

21.10.2 “或”运算符536

21.10.3 “异或”运算符536

21.10.4 求补运算符536

21.10.5 设置位536

21.10.6 清除位536

21.10.8 位字段537

21.10.7 反转位537

21.11 风格539

21.11.1 缩进540

21.11.2 大括号540

21.11.3 长代码行540

21.11.4 switch语句540

21.11.5 程序文本540

21.11.6 标识符名称541

21.11.7 名字的拼写和大写541

21.11.8 注释542

21.11.9 访问542

21.11.10 类定义542

21.11.11 包含文件542

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

21.12.2 学习C#543

21.12.3 保持联系543

21.12 下一步543

21.11.13 const543

21.11.12 assert()543

21.13 小结544

21.14 问与答544

21.15 习题545

21.15.1 测验545

21.15.2 练习545

第三篇内容回顾546

A.1 其他进制557

附录A 二进制和十六进制557

A.2 进制的转换558

A.2.1 二进制559

A.2.2 为什么用二进制559

A.2.3 位、字节和半字节560

A.2.4 什么是kB(千字节)560

A.2.5 二进制数560

A.3 十六进制560

附录B C++关键字564

附录C 运算符的优先级565

附录D 答案566