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

第1章 基本概念 1

1.1 现代C＋＋ 1

1.2 标准库 2

1.3 C＋＋程序概念 2

1.3.1 源文件和头文件 3

1.3.2 注释和空白 3

1.3.3 预处理指令和标准库头文件 3

1.3.4 函数 3

1.3.5 语句 4

1.3.6 数据的输入输出 4

1.3.7 return语句 5

1.3.8 名称空间 5

1.3.9 名称和关键字 6

1.4 类和对象 6

1.5 模板 6

1.6 代码的表示样式和编程风格 7

1.7 创建可执行文件 7

1.8 过程化编程和面向对象编程 8

1.9 表示数字 9

1.9.1 二进制数 9

1.9.2 十六进制数 10

1.9.3 负的二进制数 11

1.9.4 八进制数 12

1.9.5 Big-Endian和Little-Endian系统 12

1.9.6 浮点数 13

1.10 表示字符 14

1.10.1 ASCII码 14

1.10.2 UCS和Unicode 14

1.11 C＋＋源字符 15

1.12 本章小结 17

1.13 练习 17

第2章 基本数据类型 19

2.1 变量、数据和数据类型 19

2.1.1 定义整型变量 19

2.1.2 零初始化 22

2.1.3 定义有固定值的变量 22

2.2 整型字面量 22

2.2.1 十进制整型字面量 23

2.2.2 十六进制的整型字面量 23

2.2.3 八进制的整型字面量 24

2.2.4 二进制的整型字面量 24

2.3 整数的计算 24

2.4 赋值运算 26

2.5 sizeof运算符 29

2.6 整数的递增和递减 30

2.7 定义浮点变量 31

2.8 浮点字面量 32

2.9 浮点数的计算 32

2.9.1 缺点 32

2.9.2 无效的浮点结果 33

2.9.3 数学函数 33

2.10 输出流的格式化 35

2.11 混合的表达式和类型转换 37

2.12 显式类型转换 38

2.13 确定数值的上下限 40

2.14 使用字符变量 41

2.15 auto关键字 42

2.16 本章小结 43

2.17 练习 43

第3章 处理基本数据类型 45

3.1 运算符的优先级和相关性 45

3.2 位运算符 46

3.2.1 移位运算符 47

3.2.2 位模式下的逻辑运算 49

3.3 枚举数据类型 53

3.4 数据类型的别名 55

3.5 变量的生存期 56

3.6 全局变量 56

3.7 本章小结 59

3.8 练习 59

第4章 决策 61

4.1 比较数据值 61

4.1.1 应用比较运算符 62

4.1.2 比较浮点数值 63

4.2 if语句 63

4.2.1 嵌套的if语句 65

4.2.2 字符分类和转换 66

4.3 if-else语句 68

4.3.1 嵌套的if-else语句 69

4.3.2 理解嵌套的if语句 70

4.4 逻辑运算符 71

4.4.1 逻辑与运算符 71

4.4.2 逻辑或运算符 71

4.4.3 逻辑非运算符 72

4.4.4 组合逻辑运算符 72

4.4.5 对整数操作数应用逻辑运算符 73

4.4.6 对比逻辑运算符与位运算符 74

4.5 条件运算符 75

4.6 switch语句 76

4.7 语句块和变量作用域 81

4.8 本章小结 82

4.9 练习 83

第5章 数组和循环 85

5.1 数组 85

5.2 理解循环 87

5.3 for循环 87

5.4 避免幻数 89

5.5 用初始化列表定义数组的大小 90

5.6 确定数组的大小 90

5.7 用浮点数控制for循环 91

5.8 使用更复杂的for循环控制表达式 93

5.9 基于范围的for循环 94

5.10 while循环 95

5.11 do-while循环 96

5.12 嵌套的循环 98

5.13 跳过循环迭代 100

5.14 循环的中断 101

5.15 使用无符号整数控制for循环 103

5.16 字符数组 104

5.17 多维数组 107

5.17.1 初始化多维数组 108

5.17.2 多维字符数组 110

5.18 在运行期间给数组分配内存空间 111

5.19 数组的替代品 112

5.19.1 使用array＜T,N＞容器 113

5.19.2 使用std::vector＜T＞容器 116

5.20 本章小结 119

5.21 练习 120

第6章 指针和引用 121

6.1 什么是指针 121

6.2 地址运算符 123

6.3 间接运算符 124

6.4 为什么使用指针 125

6.5 char类型的指针 125

6.6 常量指针和指向常量的指针 128

6.7 指针和数组 130

6.7.1 指针的算术运算 130

6.7.2 使用数组名的指针表示法 132

6.8 动态内存分配 133

6.8.1 栈和自由存储区 134

6.8.2 运算符new和delete 134

6.8.3 数组的动态内存分配 135

6.9 通过指针选择成员 138

6.10 动态内存分配的危险 138

6.10.1 悬挂指针和多次释放 138

6.10.2 分配与释放的不匹配 139

6.10.3 内存泄漏 139

6.10.4 自由存储区的碎片 139

6.11 内存分配的黄金准则 140

6.12 原始指针和智能指针 140

6.12.1 使用unique_ptr＜T＞指针 141

6.12.2 使用shared_ptr＜T＞指针 143

6.13 理解引用 146

6.13.1 定义引用 146

6.13.2 在基于范围的for循环中使用引用变量 147

6.14 本章小结 148

6.15 练习 148

第7章 操作字符串 151

7.1 更强大的string类 151

7.1.1 定义string对象 151

7.1.2 string对象的操作 154

7.1.3 访问字符串中的字符 157

7.1.4 访问子字符串 158

7.1.5 比较字符串 158

7.1.6 搜索字符串 162

7.1.7 修改字符串 167

7.1.8 对比std::string与std::vector＜char＞ 170

7.2 将字符串转换为数字 171

7.3 字符串流 171

7.4 国际字符串 172

7.4.1 存储wchar_t字符的字符串 172

7.4.2 包含Unicode字符串的对象 173

7.5 原始字符串字面量 173

7.6 本章小结 174

7.7 练习 175

第8章 定义函数 177

8.1 程序的分解 177

8.1.1 类中的函数 177

8.1.2 函数的特征 178

8.2 定义函数 178

8.2.1 函数体 179

8.2.2 返回值 180

8.2.3 函数声明 181

8.3 给函数传送实参 182

8.3.1 按值传送 182

8.3.2 按引用传送 187

8.3.3 字符串视图：新的const string引用 192

8.4 默认实参值 194

8.5 main（）函数的实参 196

8.6 从函数中返回值 196

8.6.1 返回指针 197

8.6.2 返回引用 199

8.6.3 对比返回值与输出参数 200

8.6.4 返回类型推断 200

8.6.5 使用可选值 201

8.7 静态变量 203

8.8 内联函数 204

8.9 函数重载 204

8.9.1 重载和指针参数 206

8.9.2 重载和引用参数 206

8.9.3 重载和const参数 207

8.9.4 重载和默认实参值 208

8.10 递归 209

8.10.1 基本示例 209

8.10.2 递归算法 210

8.11 本章小结 215

8.12 练习 216

第9章 函数模板 219

9.1 函数模板 219

9.2 创建函数模板的实例 220

9.3 模板类型参数 221

9.4 显式指定模板实参 221

9.5 函数模板的特例 222

9.6 函数模板和重载 222

9.7 带有多个参数的函数模板 224

9.8 模板的返回类型推断 225

9.8.1 decltype和拖尾返回类型 225

9.8.2 对比decltype（auto）、拖尾decltype（）与auto 226

9.9 模板参数的默认值 226

9.10 非类型的模板参数 227

9.11 本章小结 229

9.12 练习 229

第10章 程序文件和预处理指令 231

10.1 理解转换单元 231

10.1.1 单一定义规则 231

10.1.2 程序文件和链接 232

10.1.3 确定名称的链接属性 232

10.1.4 外部函数 233

10.1.5 外部变量 233

10.1.6 内部名称 235

10.2 预处理源代码 236

10.3 定义预处理宏 236

10.3.1 定义类似于函数的宏 238

10.3.2 取消宏的定义 239

10.4 包含头文件 240

10.4.1 防止重复头文件的内容 240

10.4.2 第一个头文件 241

10.5 名称空间 242

10.5.1 全局名称空间 242

10.5.2 定义名称空间 242

10.5.3 应用using声明 244

10.5.4 函数和名称空间 244

10.5.5 未命名的名称空间 246

10.5.6 嵌套的名称空间 247

10.5.7 名称空间的别名 248

10.6 逻辑预处理指令 248

10.6.1 逻辑#if指令 248

10.6.2 测试指定标识符的值 249

10.6.3 多个代码选择 249

10.6.4 标准的预处理宏 250

10.6.5 检查头文件是否可用 251

10.7 调试方法 251

10.7.1 集成调试器 252

10.7.2 调试中的预处理指令 252

10.7.3 使用assert（）宏 254

10.8 静态断言 255

10.9 本章小结 257

10.10 练习 257

第11章 定义自己的数据类型 259

11.1 类和面向对象编程 259

11.1.1 封装 260

11.1.2 继承 262

11.1.3 多态性 263

11.2 术语 263

11.3 定义类 264

11.4 构造函数 265

11.4.1 默认构造函数 265

11.4.2 定义类的构造函数 266

11.4.3 使用default关键字 267

11.4.4 在类的外部定义函数和构造函数 267

11.4.5 默认构造函数的参数值 268

11.4.6 使用成员初始化列表 269

11.4.7 使用explicit关键字 269

11.4.8 委托构造函数 271

11.4.9 副本构造函数 272

11.5 访问私有类成员 273

11.6 this指针 274

11.7 const对象和const成员函数 275

11.7.1 const成员函数 276

11.7.2 const正确性 277

11.7.3 重载const 277

11.7.4 常量的强制转换 279

11.7.5 使用mutable关键字 279

11.8 友元 280

11.8.1 类的友元函数 280

11.8.2 友元类 281

11.9 类的对象数组 282

11.10 类对象的大小 283

11.11 类的静态成员 283

11.11.1 静态成员变量 283

11.11.2 访问静态成员变量 286

11.11.3 静态常量 286

11.11.4 类类型的静态成员变量 287

11.11.5 静态成员函数 288

11.12 析构函数 288

11.13 使用指针作为类成员 290

11.14 嵌套类 299

11.15 本章小结 302

11.16 练习 303

第12章 运算符重载 305

12.1 为类实现运算符 305

12.1.1 运算符重载 305

12.1.2 实现重载运算符 306

12.1.3 非成员运算符函数 307

12.1.4 提供对运算符的全部支持 308

12.1.5 在类中实现所有的比较运算符 309

12.2 可以重载的运算符 311

12.3 运算符函数习语 313

12.4 为输出流重载＜＜运算符 313

12.5 重载算术运算符 315

12.6 成员与非成员函数 318

12.7 重载一元运算符 320

12.8 重载递增和递减运算符 321

12.9 重载下标运算符 322

12.10 函数对象 326

12.11 重载类型转换 326

12.12 重载赋值运算符 327

12.12.1 实现复制赋值运算符 328

12.12.2 复制赋值运算符与副本构造函数 330

12.12.3 赋值不同类型 330

12.13 本章小结 331

12.14 练习 331

第13章 继承 333

13.1 类和面向对象编程 333

13.2 类的继承 334

13.2.1 继承和聚合 335

13.2.2 派生类 335

13.3 把类的成员声明为protected 337

13.4 派生类成员的访问级别 338

13.4.1 在类层次结构中使用访问修饰符 338

13.4.2 在类层次结构中选择访问修饰符 339

13.4.3 改变继承成员的访问修饰符 340

13.5 派生类中的构造函数 341

13.5.1 派生类中的副本构造函数 343

13.5.2 派生类中的默认构造函数 344

13.5.3 继承构造函数 344

13.6 继承中的析构函数 345

13.7 重复的成员变量名 347

13.8 重复的成员函数名 347

13.9 多重继承 348

13.9.1 多个基类 348

13.9.2 继承成员的模糊性 349

13.9.3 重复继承 352

13.9.4 虚基类 353

13.10 在相关的类类型之间转换 353

13.11 本章小结 354

13.12 练习 354

第14章 多态性 355

14.1 理解多态性 355

14.1.1 使用基类指针 355

14.1.2 调用继承的函数 357

14.1.3 虚函数 359

14.1.4 虚函数中的默认实参值 365

14.1.5 通过引用调用虚函数 366

14.1.6 多态集合 366

14.1.7 通过指针释放对象 367

14.1.8 在指针和类对象之间转换 369

14.1.9 动态强制转换 370

14.1.10 调用虚函数的基类版本 373

14.1.11 在构造函数或析构函数中调用虚函数 374

14.2 多态性引发的成本 375

14.3 确定动态类型 376

14.4 纯虚函数 378

14.4.1 抽象类 379

14.4.2 用作接口的抽象类 381

14.5 本章小结 382

14.6 练习 383

第15章 运行时错误和异常 385

15.1 处理错误 385

15.2 理解异常 386

15.2.1 抛出异常 386

15.2.2 异常处理过程 388

15.2.3 导致抛出异常的代码 389

15.2.4 嵌套的try块 389

15.3 用类对象作为异常 392

15.3.1 匹配catch处理程序和异常 393

15.3.2 用基类处理程序捕获派生类异常 394

15.4 重新抛出异常 396

15.5 未处理的异常 398

15.6 捕获所有的异常 399

15.7 不抛出异常的函数 400

15.7.1 noexcept限定符 400

15.7.2 异常和析构函数 401

15.8 异常和资源泄漏 401

15.8.1 资源获取即初始化 403

15.8.2 用于动态内存的标准RAII类 404

15.9 标准库异常 405

15.9.1 异常类的定义 406

15.9.2 使用标准异常 407

15.10 本章小结 409

15.11 练习 410

第16章 类模板 413

16.1 理解类模板 413

16.2 定义类模板 414

16.2.1 模板参数 414

16.2.2 简单的类模板 415

16.3 定义类模板的成员函数 416

16.3.1 构造函数模板 416

16.3.2 析构函数模板 417

16.3.3 下标运算符模板 417

16.3.4 赋值运算符模板 419

16.4 创建类模板的实例 422

16.5 非类型的类模板参数 426

16.5.1 带有非类型参数的成员函数的模板 427

16.5.2 非类型参数的实参 431

16.5.3 对比非类型模板实参与构造函数实参 431

16.6 模板参数的默认值 432

16.7 模板的显式实例化 432

16.8 类模板特化 433

16.8.1 定义类模板特化 433

16.8.2 部分模板特化 433

16.8.3 从多个部分特化中选择 434

16.9 在类模板中使用static_assert（） 434

16.10 类模板的友元 435

16.11 带有嵌套类的类模板 436

16.11.1 栈成员的函数模板 438

16.11.2 消除依赖名称的歧义 441

16.12 本章小结 443

16.13 练习 443

第17章 移动语义 445

17.1 lvalue和rvalue 445

17.2 移动对象 447

17.2.1 传统方法 449

17.2.2 定义移动成员 449

17.3 显式移动对象 452

17.3.1 只能移动的类型 452

17.3.2 移动对象的继续使用 453

17.4 看似矛盾的情况 454

17.4.1 std::move（）并不移动任何东西 454

17.4.2 rvalue引用是一个lvalue 454

17.5 继续探讨函数定义 455

17.5.1 按rvalue引用传送 455

17.5.2 按值传送的归来 456

17.5.3 按值返回 458

17.6 继续讨论定义移动成员 459

17.6.1 总是添加noexcept 459

17.6.2 “移动后交换”技术 462

17.7 特殊成员函数 463

17.7.1 默认移动成员 464

17.7.2 5的规则 464

17.7.3 0的规则 465

17.8 本章小结 466

17.9 练习 466

第18章 头等函数 467

18.1 函数指针 467

18.1.1 定义函数指针 467

18.1.2 高阶函数的回调函数 469

18.1.3 函数指针的类型别名 471

18.2 函数对象 472

18.2.1 基本的函数对象 472

18.2.2 标准函数对象 473

18.2.3 参数化函数对象 474

18.3 lambda表达式 475

18.3.1 定义lambda表达式 475

18.3.2 命名lambda闭包 476

18.3.3 向函数模板传送lambda表达式 476

18.3.4 捕获子句 477

18.4 std::function＜＞模板 481

18.5 本章小结 482

18.6 练习 483

第19章 容器与算法 485

19.1 容器 485

19.1.1 顺序容器 485

19.1.2 栈和队列 488

19.1.3 集合 489

19.1.4 映射 491

19.2 迭代器 494

19.2.1 迭代器设计模式 495

19.2.2 标准库容器的迭代器 496

19.2.3 数组的迭代器 502

19.3 算法 503

19.3.1 第一个示例 503

19.3.2 寻找元素 504

19.3.3 输出多个值 505

19.3.4 删除-擦除技术 507

19.3.5 排序 507

19.3.6 并行算法 508

19.4 本章小结 508

19.5 练习 509