C++程序设计 思想与方法 第3版 慕课版PDF电子书下载

第1章 绪论 1

1.1 程序设计概述 1

1.2 计算机组成 1

1.2.1 计算机硬件 2

1.2.2 计算机软件 3

1.3 程序设计语言 3

1.3.1 机器语言 3

1.3.2 汇编语言 4

1.3.3 高级语言 4

1.3.4 C++语言 5

1.4 程序设计过程 5

1.4.1 算法设计 5

1.4.2 编码 8

1.4.3 编译和链接 8

1.4.4 调试与维护 8

1.5 小结 9

1.6 习题 9

第2章 程序的基本组成 11

2.1 程序的基本结构 11

2.1.1 注释 12

2.1.2 预编译 12

2.1.3 名字空间 13

2.1.4 主程序 13

2.2 常量与变量 14

2.2.1 变量定义 14

2.2.2 数据类型 16

2.2.3 常量与符号常量 21

2.2.4 C++11的扩展 24

2.3 数据的输入/输出 25

2.3.1 数据的输入 25

2.3.2 数据的输出 26

2.4 算术运算 27

2.4.1 算术表达式 27

2.4.2 各种类型的数值间的混合运算 27

2.4.3 强制类型转换 27

2.4.4 数学函数库 28

2.4.5 C++11的扩展 29

2.5 赋值运算 29

2.5.1 赋值表达式 29

2.5.2 赋值的嵌套 30

2.5.3 复合赋值运算 31

2.5.4 自增和自减运算符 32

2.6 程序规范及常见错误 33

2.7 小结 34

2.8 习题 34

第3章 分支程序设计 37

3.1 关系表达式 37

3.2 逻辑表达式 38

3.3 if语句 39

3.3.1 if语句的格式 39

3.3.2 if语句的嵌套 43

3.3.3 条件表达式 44

3.4 switch语句及其应用 46

3.5 编程规范及常见错误 52

3.6 小结 52

3.7 习题 53

第4章 循环程序设计 56

4.1 计数循环 56

4.1.1 for语句 56

4.1.2 for语句的进一步讨论 61

4.1.3 for循环的嵌套 61

4.1.4 C++11的扩展 62

4.2 break和continue语句 62

4.3 基于哨兵的循环 64

4.3.1 while语句 64

4.3.2 do-while语句 68

4.4 循环的中途退出 69

4.5 枚举法 70

4.6 贪婪法 73

4.7 编程规范及常见错误 75

4.8 小结 75

4.9 习题 75

第5章 批量数据处理——数组 79

5.1 一维数组 79

5.1.1 一维数组的定义 79

5.1.2 一维数组元素的引用 80

5.1.3 一维数组的内存映像 81

5.1.4 一维数组的应用 81

5.1.5 C++11的扩展 83

5.2 查找 84

5.2.1 顺序查找 84

5.2.2 二分查找 85

5.3 排序 87

5.3.1 直接选择排序法 87

5.3.2 冒泡排序法 89

5.4 二维数组 90

5.4.1 二维数组的定义 91

5.4.2 二维数组元素的引用 91

5.4.3 二维数组的内存映像 92

5.4.4 二维数组的应用 92

5.5 字符串 96

5.5.1 字符串的存储及初始化 96

5.5.2 字符串的输入/输出 97

5.5.3 字符串处理函数 97

5.5.4 字符串的应用 98

5.6 编程规范及常见错误 100

5.7 小结 101

5.8 习题 101

第6章 过程封装——函数 104

6.1 函数定义 105

6.1.1 函数的基本结构 105

6.1.2 return语句 105

6.1.3 函数示例 105

6.2 函数的使用 108

6.2.1 函数原型的声明 108

6.2.2 函数调用 109

6.2.3 将函数与主程序放在一起 109

6.2.4 函数调用过程 110

6.3 变量的作用域 113

6.4 变量的存储类别 115

6.4.1 自动变量 115

6.4.2 静态变量 115

6.4.3 寄存器变量 117

6.4.4 外部变量 117

6.5 数组作为函数参数 119

6.6 带默认值的函数 124

6.7 内联函数 125

6.8 重载函数 126

6.9 函数模板 128

6.10 递归函数 129

6.10.1 递归函数的基本概念 129

6.10.2 递归函数的应用 131

6.11 基于递归的算法 136

6.11.1 回溯法 136

6.11.2 分治法 140

6.11.3 动态规划 143

6.12 C++11的扩展 146

6.12.1 constexpr函数 146

6.12.2 尾置返回类型 146

6.13 编程规范及常见错误 147

6.14 小结 147

6.15 习题 148

第7章 间接访问——指针 151

7.1 指针的概念 151

7.1.1 指针与间接访问 151

7.1.2 指针变量的定义 151

7.1.3 指针的基本操作 152

7.1.4 C++11的扩展 155

7.2 指针运算与数组 155

7.2.1 指针运算 155

7.2.2 用指针访问数组 156

7.3 动态内存分配 156

7.3.1 动态变量 156

7.3.2 动态变量的创建 157

7.3.3 动态变量的消亡 158

7.3.4 内存泄漏 158

7.3.5 查找new操作的失误 158

7.3.6 动态变量应用 159

7.3.7 C++11的扩展 160

7.4 字符串再讨论 161

7.5 指针与函数 161

7.5.1 指针作为形式参数 161

7.5.2 数组作为函数参数再讨论 164

7.5.3 字符串作为函数的参数 166

7.5.4 返回指针的函数 166

7.6 引用类型与函数 167

7.6.1 引用类型 167

7.6.2 引用传递 169

7.6.3 返回引用的函数 171

7.6.4 C++11的扩展 171

7.7 指针数组与多级指针 172

7.7.1 指针数组 172

7.7.2 main函数的参数 173

7.7.3 多级指针 175

7.7.4 动态二维数组 176

7.8 函数指针 177

7.8.1 指向函数的指针 177

7.8.2 函数指针作为函数参数 178

7.8.3 用于菜单选择 180

7.8.4 C++11的扩展 181

7.9 编程规范及常见错误 183

7.10 小结 183

7.11 习题 184

第8章 数据封装——结构体 186

8.1 记录的概念 186

8.2 记录的使用 187

8.2.1 结构体类型的定义 187

8.2.2 结构体类型的变量的定义 188

8.2.3 结构体类型的变量的使用 189

8.3 结构体作为函数的参数 190

8.4 链表 192

8.4.1 链表的概念 192

8.4.2 单链表的存储 193

8.4.3 单链表的操作 193

8.5 编程规范及常见错误 198

8.6 小结 198

8.7 习题 198

第9章 模块化开发 200

9.1 结构化程序设计 200

9.2 自顶向下分解 200

9.2.1 顶层分解 201

9.2.2 prn_instruction的实现 201

9.2.3 play函数的实现 201

9.2.4 get_call_from_user的实现 202

9.3 模块划分 203

9.4 设计自己的库 209

9.5 编程规范及常见错误 214

9.6 小结 214

9.7 习题 214

第10章 创建新的类型 216

10.1 面向对象程序设计 216

10.1.1 抽象的过程 216

10.1.2 面向对象程序设计的特点 217

10.1.3 库和类 218

10.2 类的定义 224

10.3 对象的使用 228

10.3.1 对象的定义 228

10.3.2 对象的操作 228

10.3.3 this指针 230

10.4 对象的构造与析构 231

10.4.1 对象的构造 231

10.4.2 对象的析构 235

10.4.3 类与对象应用实例 237

10.4.4 C++11的扩展 240

10.5 const与类 242

10.5.1 常量数据成员 242

10.5.2 常量对象 243

10.5.3 常量成员函数 243

10.6 静态成员 244

10.6.1 静态数据成员 244

10.6.2 静态成员函数 245

10.6.3 静态常量成员 247

10.7 友元 248

10.8 编程规范及常见错误 250

10.9 小结 250

10.10 习题 251

第11章 运算符重载 254

11.1 运算符重载的意义 254

11.2 运算符重载的方法 255

11.3 5个特殊运算符的重载 259

11.3.1 赋值运算符的重载 259

11.3.2 下标运算符的重载 260

11.3.3 函数调用运算符的重载 261

11.3.4 ++和--运算符的重载 262

11.3.5 输入/输出运算符的重载 265

11.3.6 C++11的扩展 267

11.4 自定义类型转换函数 267

11.4.1 内置类型到类类型的转换 268

11.4.2 类类型到其他类型的转换 268

11.4.3 C++11的扩展 269

11.5 运算符重载的应用 269

11.5.1 完整的Rational类的定义和使用 269

11.5.2 完整的DoubleArray类的定义和使用 272

11.6 编程规范及常见错误 275

11.7 小结 276

11.8 习题 276

第12章 组合与继承 279

12.1 组合 279

12.2 继承 284

12.2.1 派生类的定义 285

12.2.2 继承的应用 288

12.2.3 重定义基类的函数 292

12.2.4 派生类对象的赋值 293

12.2.5 派生类作为基类 294

12.3 运行时的多态性 295

12.3.1 将派生类对象隐式转换为基类对象 295

12.3.2 多态性与虚函数 297

12.3.3 虚析构函数 300

12.3.4 C++11的扩展 300

12.4 纯虚函数和抽象类 301

12.4.1 纯虚函数 301

12.4.2 抽象类 301

12.5 编程规范及常见错误 302

12.6 小结 302

12.7 习题 302

第13章 泛型机制——模板 305

13.1 类模板的定义 305

13.2 类模板的实例化 307

13.3 模板的编译 308

13.4 非类型参数和参数的默认值 308

13.5 类模板的友元 309

13.5.1 普通友元 309

13.5.2 模板的特定实例的友元 310

13.6 类模板作为基类 314

13.7 编程规范及常见错误 314

13.8 小结 315

13.9 习题 315

第14章 输入/输出与文件 316

14.1 流与标准库 316

14.2 输入/输出缓冲 317

14.3 基于控制台的输入/输出 318

14.3.1 输出流 318

14.3.2 输入流 320

14.3.3 格式化的输入/输出 323

14.4 基于文件的输入/输出 326

14.4.1 文件的概念 326

14.4.2 文件和流 327

14.4.3 文件的顺序访问 329

14.4.4 文件的随机访问 331

14.4.5 用流式文件处理含有记录的文件 333

14.5 基于字符串的输入/输出 339

14.6 编程规范及常见错误 340

14.7 小结 340

14.8 习题 340

第15章 异常处理 343

15.1 传统的异常处理方法 343

15.2 异常处理机制 343

15.2.1 异常抛出 344

15.2.2 异常捕获 345

15.3 异常规格说明 350

15.4 编程规范及常见错误 351

15.5 小结 351

15.6 习题 351

第16章 容器和迭代器 353

16.1 容器 353

16.2 迭代器 353

16.3 容器和迭代器的设计示例 354

16.3.1 用数组实现的容器 354

16.3.2 用链表实现的容器 357

16.4 小结 359

16.5 习题 360

参考文献 361