C++入门经典 第6版PDF电子书下载

第1部分 C＋＋入门 1

第1章 编写第一个程序 1

1.1 使用C＋＋ 1

1.2 编译和链接源代码 2

1.3 创建您的第一个程序 3

1.4 总结 4

1.5 问与答 4

1.6 作业 4

第2章 程序的组成部分 6

2.1 使用C＋＋的原因 6

2.1.1 编程风格 7

2.1.2 C＋＋和面向对象编程 8

2.2 程序的组成部分 9

2.2.1 预处理器编译指令 9

2.2.2 源代码行 10

2.3 注释 11

2.4 函数 11

2.5 总结 13

2.6 问与答 14

2.7 作业 14

第3章 创建变量和常量 16

3.1 变量是什么 16

3.1.1 在内存中存储变量 17

3.1.2 无符号变量和带符号变量 18

3.1.3 变量类型 18

3.2 定义变量 19

3.3 给变量赋值 21

3.4 使用类型定义 22

3.5 常量 22

3.5.1 定义常量 23

3.5.2 枚举常量 23

3.6 自动变量 24

3.7 总结 26

3.8 问与答 26

3.9 作业 27

第4章 使用表达式、语句和运算符 28

4.1 语句 28

4.1.1 空白 28

4.1.2 复合语句 29

4.2 表达式 29

4.3 运算符 30

4.3.1 赋值运算符 30

4.3.2 数学运算符 30

4.3.3 组合运算符 31

4.3.4 递增和递减运算符 31

4.3.5 前缀运算符和后缀运算符 31

4.3.6 运算符优先级 33

4.3.7 关系运算符 35

4.4 if-else条件语句 35

4.4.1 else子句 36

4.4.2 复合if语句 37

4.5 逻辑运算符 38

4.5.1 与运算符 38

4.5.2 或运算符 39

4.5.3 非运算符 39

4.5.4 关系运算符和逻辑运算符的优先级 39

4.6 棘手的表达式值 39

4.7 总结 40

4.8 问与答 40

4.9 作业 41

第5章 调用函数 42

5.1 函数是什么 42

5.2 声明和定义函数 42

5.3 在函数中使用变量 44

5.3.1 局部变量 44

5.3.2 全局变量 46

5.4 函数形参 47

5.5 从函数返回值 47

5.6 默认函数形参 49

5.7 函数重载 50

5.8 自动确定返回类型 51

5.9 总结 53

5.10 问与答 53

5.11 作业 53

第6章 控制程序流程 55

6.1 循环 55

6.2 while循环 55

6.2.1 退出循环 56

6.2.2 跳到下一次循环 57

6.3 do-while循环 58

6.4 for循环 59

6.4.1 高级for循环 60

6.4.2 嵌套循环 61

6.5 switch语句 62

6.6 总结 64

6.7 问与答 64

6.8 作业 65

第7章 使用数组和字符串存储信息 66

7.1 数组是什么 66

7.2 写入时超过数组末尾 68

7.3 初始化数组 68

7.4 多维数组 69

7.4.1 初始化多维数组 70

7.4.2 内存简介 71

7.5 字符数组 71

7.6 复制字符串 73

7.7 使用foreach循环读取数组 74

7.8 总结 75

7.9 问与答 75

7.10 作业 75

第2部分 类 77

第8章 创建基本类 77

8.1 类型是什么 77

8.2 创建新类型 77

8.3 类和成员 78

8.3.1 声明类 78

8.3.2 创建对象 79

8.4 访问类成员 79

8.5 实现成员函数 80

8.6 创建和删除对象 82

8.6.1 默认构造函数 83

8.6.2 编译器提供的构造函数 83

8.7 总结 85

8.8 问与答 86

8.9 作业 86

第9章 高级类 88

9.1 const成员函数 88

9.2 接口和实现 89

9.3 组织类声明和函数定义 89

9.4 内联实现 89

9.5 将其他类用作成员数据的类 91

9.6 总结 95

9.7 问与答 95

9.8 作业 95

第3部分 内存管理 97

第10章 创建指针 97

10.1 理解指针及其用途 97

10.1.1 在指针中存储地址 99

10.1.2 间接运算符（间接地使用指针） 100

10.1.3 指针、地址和变量 101

10.1.4 使用指针操作数据 102

10.1.5 查看存储在指针中的地址 103

10.1.6 为何使用指针 104

10.2 栈和堆 104

10.2.1 使用关键字new 105

10.2.2 使用关键字delete 106

10.2.3 避免内存泄露 107

10.3 空指针常量 108

10.4 总结 109

10.5 问与答 109

10.6 作业 109

第11章 开发高级指针 111

11.1 在堆中创建对象 111

11.2 删除对象 111

11.3 使用指针访问数据成员 112

11.4 堆中的数据成员 113

11.5 this指针 115

11.6 悬摆指针 116

11.7 const指针 116

11.8 const指针和const成员函数 117

11.9 总结 118

11.10 问与答 118

11.11 作业 119

第12章 创建引用 120

12.1 什么是引用 120

12.2 创建引用 120

12.3 将地址运算符用于引用 121

12.4 可引用的目标 123

12.5 空指针和空引用 124

12.6 按引用传递函数参数 124

12.6.1 使用指针实现swap（） 125

12.6.2 使用引用实现swap（） 126

12.7 理解函数头和原型 127

12.8 返回多个值 127

12.9 总结 130

12.10 问与答 130

12.11 作业 130

第13章 高级引用和指针 132

13.1 按引用传递以提高效率 132

13.2 传递const指针 134

13.3 作为指针替代品的引用 136

13.4 什么情况下使用引用以及什么情况下使用指针 138

13.5 指向对象的引用不在作用域内 138

13.6 返回指向堆中对象的引用 139

13.7 谁拥有指针 141

13.8 总结 141

13.9 问与答 141

13.10 作业 141

第4部分 高级C＋＋ 143

第14章 高级函数 143

14.1 重载成员函数 143

14.2 使用默认值 145

14.3 初始化对象 146

14.4 复制构造函数 147

14.5 编译阶段常量表达式 150

14.6 总结 151

14.7 问与答 152

14.8 作业 152

第15章 运算符重载 154

15.1 重载运算符 154

15.1.1 编写递增方法 155

15.1.2 重载后缀运算符 157

15.1.3 重载加法运算符 158

15.1.4 对运算符重载的限制 160

15.1.5 赋值运算符 160

15.2 转换运算符 162

15.3 总结 165

15.4 问与答 165

15.5 作业 165

第5部分 继承和多态 167

第16章 使用继承扩展类 167

16.1 什么是继承 167

16.1.1 继承和派生 168

16.1.2 动物和继承 168

16.1.3 派生语法 168

16.2 私有和保护 170

16.3 构造函数和析构函数 171

16.4 将参数传递给基类构造函数 173

16.5 重写函数 177

16.5.1 重载和重写 178

16.5.2 隐藏基类的成员函数 178

16.5.3 调用基类的成员函数 180

16.6 总结 181

16.7 问与答 181

16.8 作业 181

第17章 使用多态和派生类 183

17.1 使用虚成员函数实现多态 183

17.2 虚成员函数的工作原理 186

17.2.1 不能通过基类指针访问派生类特有的方法 187

17.2.2 切除 188

17.2.3 虚析构函数 189

17.2.4 虚复制构造函数 190

17.2.5 使用虚成员函数的代价 192

17.3 总结 193

17.4 问与答 193

17.5 作业 193

第18章 使用高级多态 195

18.1 单继承存在的问题 195

18.2 抽象数据类型 198

18.2.1 纯虚函数 201

18.2.2 实现纯虚函数 202

18.2.3 复杂的抽象层次结构 204

18.2.4 哪些类是抽象的 207

18.3 总结 208

18.4 问与答 208

18.5 作业 208

第6部分 特殊主题 210

第19章 使用链表存储信息 210

19.1 链表和其他结构 210

19.2 链表案例研究 211

19.2.1 委托 211

19.2.2 链表的组成部分 211

19.3 作为对象的链表 217

19.4 总结 218

19.5 问与答 218

19.6 作业 219

第20章 使用特殊的类、函数和指针 220

20.1 静态成员数据 220

20.2 静态成员函数 222

20.3 将其他类对象作为成员 223

20.3.1 访问被包含类的成员 228

20.3.2 禁止访问内部类的成员 228

20.3.3 按引用还是按值复制 229

20.4 友元类和友元函数 229

20.5 函数指针 229

20.5.1 函数指针数组 232

20.5.2 将函数指针传递给其他函数 234

20.5.3 将typedef用于函数指针 236

20.5.4 成员函数指针 236

20.5.5 成员函数指针数组 238

20.6 总结 240

20.7 问与答 240

20.8 作业 240

第21章 使用C＋＋14新增的功能 242

21.1 最新的C＋＋版本 242

21.2 使用auto来指定函数的返回类型 242

21.3 改进的数值字面量 245

21.4 关键字constexpr 245

21.5 Lambda表达式 247

21.6 总结 248

21.7 问与答 248

21.8 作业 249

第22章 面向对象分析和设计 250

22.1 开发周期 250

22.2 模拟报警系统 250

22.2.1 概念化 251

22.2.2 分析和需求 251

22.2.3 高级设计和详细设计 252

22.2.4 其他对象 252

22.2.5 设计类 252

22.2.6 添加其他类 253

22.2.7 事件循环 253

22.3 案例研究 255

22.3.1 三思而后行 256

22.3.2 分而治之 256

22.3.3 邮件格式 257

22.3.4 初步类设计 257

22.3.5 同根和不同根 258

22.3.6 设计接口 259

22.3.7 建立原型 260

22.3.8 80/80规则 260

22.3.9 设计PostMasterMessage类 261

22.3.10 应用程序编程接口 261

22.3.11 小组编程 262

22.3.12 需要不断考虑的设计因素 262

22.3.13 使用驱动程序 263

22.4 总结 269

22.5 问与答 269

22.6 作业 269

第23章 创建模板 271

23.1 什么是模板 271

23.2 模板实例 271

23.3 模板的定义 272

23.4 使用模板实例 277

23.5 总结 281

23.6 问与答 282

23.7 作业 282

第24章 处理异常和错误 284

24.1 程序中的各种错误 284

24.2 处理意外情况 285

24.3 异常 285

24.4 使用try块和catch块 289

24.4.1 捕获异常 289

24.4.2 使用多条catch语句 289

24.4.3 使用引用以多态方式捕获异常 290

24.5 编写专业级代码 293

24.5.1 大括号 293

24.5.2 长代码行 294

24.5.3 switch语句 294

24.5.4 程序文本 294

24.5.5 标识符命名 295

24.5.6 名称的拼写和大写 295

24.5.7 注释 296

24.5.8 设置访问权限 296

24.5.9 类定义 297

24.5.10 包含文件 297

24.5.11 使用const 297

24.6 总结 297

24.7 问与答 297

24.8 作业 298

第7部分 附录 299

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

附录B 术语表 306

附录C 配套网站 312

附录D 在Windows系统中使用C＋＋编译器MinGW 313