第1章 基本概念

1.1 现代C＋＋

1.2 C＋＋程序概念

1.2.1 注释和空白

1.2.2 预处理指令和头文件

1.2.3 函数

1.2.4 语句

1.2.5 数据输入输出

1.2.6 return语句

1.2.7 名称空间

1.2.8 名称和关键字

1.3 类和对象

1.4 模板

1.5 程序文件

1.6 标准库

1.7 代码的表示样式

1.8 创建可执行文件

1.9 表示数字

1.9.1 二进制数

1.9.2 十六进制数

1.9.3 负的二进制数

1.9.4 八进制数

1.9.5 Big-Endian和Little-Endian系统

1.9.6 浮点数

1.10 表示字符

1.10.1 ASCII码

1.10.2 UCS和Unicode

1.11 C＋＋源字符

1.11.1 三字符序列

1.11.2 转义序列

1.12 过程化编程方法和面向对象编程方法

1.13 本章小结

1.14 练习

第2章 基本数据类型

2.1 变量、数据和数据类型

2.1.1 定义整型变量

2.1.2 定义有固定值的变量

2.2 整型字面量

2.2.1 十进制整型字面量

2.2.2 十六进制的整型字面量

2.2.3 八进制的整型字面量

2.2.4 二进制的整型字面量

2.3 整数的计算

2.4 op＝赋值运算符

2.5 using声明和指令

2.6 sizeof运算符

2.7 整数的递增和递减

2.8 定义浮点变量

2.8.1 浮点字面量

2.8.2 浮点数的计算

2.8.3 缺点

2.8.4 无效的浮点结果

2.9 数值函数

2.10 流输出的格式化

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

2.11.1 显式类型转换

2.11.2 老式的强制转换

2.12 确定数值的上下限

2.13 使用字符变量

2.13.1 使用Unicode字符

2.13.2 auto关键字

2.13.3 lvalue和rvalue

2.14 本章小结

2.15 练习

第3章 处理基本数据类型

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

3.2 按位运算符

3.2.1 移位运算符

3.2.2 使用按位与运算符

3.2.3 使用按位或运算符

3.2.4 使用按位异或运算符

3.3 枚举数据类型

3.4 数据类型的同义词

3.5 变量的生存期

3.5.1 定位变量的定义

3.5.2 全局变量

3.5.3 静态变量

3.5.4 外部变量

3.6 本章小结

3.7 练习

第4章 决策

4.1 比较数据值

4.1.1 应用比较运算符

4.1.2 比较浮点数值

4.2 if语句

4.2.1 嵌套的if语句

4.2.2 不依赖编码的字符处理

4.3 if-else语句

4.3.1 嵌套的if-else语句

4.3.2 理解嵌套的if语句

4.4 逻辑运算符

4.4.1 逻辑与运算符

4.4.2 逻辑或运算符

4.4.3 逻辑非运算符

4.5 条件运算符

4.6 switch语句

4.7 无条件分支

4.8 语句块和变量作用域

4.9 本章小结

4.10 练习

第5章 数组和循环

5.1 数据数组

5.2 理解循环

5.3 for循环

5.3.1 避免幻数

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

5.3.3 确定数组的大小

5.3.4 用浮点数值控制for循环

5.3.5 使用更复杂的循环控制表达式

5.3.6 逗号运算符

5.3.7 基于区域的for循环

5.4 while循环

5.5 do-while循环

5.6 嵌套的循环

5.7 跳过循环迭代

5.8 循环的中断

5.9 字符数组

5.10 多维数组

5.10.1 初始化多维数组

5.10.2 在默认情况下设置维数

5.10.3 多维字符数组

5.11 数组的替代品

5.11.1 使用array＜T,N＞容器

5.11.2 使用std::vector＜T＞容器

5.11.3 矢量的容量和大小

5.11.4 删除矢量容器中的元素

5.12 本章小结

5.13 练习

第6章 指针和引用

6.1 什么是指针

6.1.1 地址运算符

6.1.2 间接运算符

6.1.3 为什么使用指针

6.2 char类型的指针

6.3 常量指针和指向常量的指针

6.4 指针和数组

6.4.1 指针的算术运算

6.4.2 计算两个指针之间的差

6.4.3 使用数组名的指针表示法

6.5 动态内存分配

6.5.1 栈和堆

6.5.2 运算符new和delete

6.5.3 数组的动态内存分配

6.5.4 通过指针选择成员

6.6 动态内存分配的危险

6.6.1 内存泄漏

6.6.2 自由存储区的碎片

6.7 原指针和智能指针

6.7.1 使用unique_ptr＜T＞指针

6.7.2 使用shared_ptr＜T＞指针

6.7.3 比较shared_ptr＜T＞对象

6.7.4 weak_ptr＜T＞指针

6.8 理解引用

6.8.1 定义左值引用

6.8.2 在基于区域的for循环中使用引用变量

6.8.3 定义右值引用

6.9 本章小结

6.10 练习

第7章 操作字符串

7.1 更好的string类型

7.1.1 定义string对象

7.1.2 string对象的操作

7.1.3 访问字符串中的字符

7.1.4 访问子字符串

7.1.5 比较字符串

7.1.6 搜索字符串

7.1.7 修改字符串

7.2 国际字符串

7.3 包含Unicode字符串的对象

7.4 原字符串字面量

7.5 本章小结

7.6 练习

第8章 定义函数

8.1 程序的分解

8.1.1 类中的函数

8.1.2 函数的特征

8.2 定义函数

8.2.1 函数体

8.2.2 函数声明

8.3 给函数传送参数

8.3.1 按值传送机制

8.3.2 按引用传送

8.3.3 main（）的参数

8.4 默认的参数值

8.5 从函数中返回值

8.5.1 返回指针

8.5.2 返回引用

8.6 内联函数

8.7 静态变量

8.8 函数的重载

8.8.1 重载和指针参数

8.8.2 重载和引用参数

8.8.3 重载和const参数

8.8.4 重载和默认参数值

8.9 函数模板

8.9.1 创建函数模板的实例

8.9.2 显式指定模板参数

8.9.3 函数模板的特例

8.9.4 函数模板和重载

8.9.5 带有多个参数的函数模板

8.9.6 非类型的模板参数

8.10 拖尾返回类型

8.11 函数指针

8.12 递归

8.12.1 应用递归

8.12.2 Quicksort算法

8.12.3 main（）函数

8.12.4 extract_words（）函数

8.12.5 swap（）函数

8.12.6 sort（）函数

8.12.7 max_word_length（）函数

8.12.8 show_words（）函数

8.13 本章小结

8.14 练习

第9章 lambda表达式

9.1 lambda表达式简介

9.2 定义lambda表达式

9.3 lambda表达式的命名

9.4 把lambda表达式传递给函数

9.4.1 接受lambda表达式变元的函数模板

9.4.2 lambda变元的函数参数类型

9.4.3 使用std::function模板类型

9.5 捕获子句

9.6 在模板中使用lambda表达式

9.7 lambda表达式中的递归

9.8 本章小结

9.9 练习

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

10.1 理解转换单元

10.1.1 “一个定义”规则

10.1.2 程序文件和链接

10.1.3 确定名称的链接属性

10.1.4 外部名称

10.1.5 具有外部链接属性的const变量

10.2 预处理源代码

10.3 定义预处理标识符

10.4 包含头文件

10.5 名称空间

10.5.1 全局名称空间

10.5.2 定义名称空间

10.5.3 应用using声明

10.5.4 函数和名称空间

10.5.5 未命名的名称空间

10.5.6 名称空间的别名

10.5.7 嵌套的名称空间

10.6 逻辑预处理指令

10.6.1 逻辑＃if指令

10.6.2 测试指定标识符的值

10.6.3 多个代码选择

10.6.4 标准的预处理宏

10.7 调试方法

10.7.1 集成调试器

10.7.2 调试中的预处理指令

10.7.3 使用assert宏

10.7.4 关闭断言机制

10.8 静态断言

10.9 本章小结

10.10 练习

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

11.1 类和面向对象编程

11.1.1 封装

11.1.2 继承

11.1.3 多态性

11.1.4 术语

11.2 定义类

11.3 构造函数

11.3.1 在类的外部定义构造函数

11.3.2 默认构造函数的参数值

11.3.3 在构造函数中使用初始化列表

11.3.4 使用explicit关键字

11.3.5 委托构造函数

11.3.6 默认的副本构造函数

11.4 访问私有类成员

11.5 友元

11.5.1 类的友元函数

11.5.2 友元类

11.6 this指针

11.7 const对象和const函数成员

11.8 类的对象数组

11.9 类对象的大小

11.10 类的静态成员

11.10.1 静态数据成员

11.10.2 类的静态函数成员

11.11 析构函数

11.12 类对象的指针和引用

11.13 将指针作为类的成员

11.13.1 定义Package类

11.13.2 定义TruckLoad类

11.13.3 实现TruckLoad类

11.14 嵌套类

11.15 本章小结

11.16 练习

第12章 运算符重载

12.1 为类实现运算符

12.1.1 运算符重载

12.1.2 可以重载的运算符

12.1.3 实现重载运算符

12.1.4 全局运算符函数

12.1.5 提供对运算符的全部支持

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

12.2 运算符函数术语

12.3 默认的类成员

12.3.1 定义析构函数

12.3.2 何时定义副本构造函数

12.3.3 实现赋值运算符

12.3.4 实现移动操作

12.4 重载算术运算符

12.4.1 改进输出操作

12.4.2 根据一个运算符实现另一个运算符

12.5 重载下标运算符

12.6 重载类型转换

12.7 重载递增和递减运算符

12.8 函数对象

12.9 本章小结

12.10 练习

第13章 继承

13.1 类和面向对象编程

13.2 类的继承

13.2.1 继承和聚合

13.2.2 派生类

13.3 把类的成员声明为protected

13.4 派生类成员的访问级别

13.4.1 在类层次结构中使用访问指定符

13.4.2 改变继承成员的访问指定符

13.5 派生类中的构造函数操作

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

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

13.5.3 继承构造函数

13.6 继承中的析构函数

13.7 重复的成员名

13.8 重复的函数成员名

13.9 多重继承

13.9.1 多个基类

13.9.2 继承成员的模糊性

13.9.3 重复的继承

13.9.4 虚基类

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

13.11 本章小结

13.12 练习

第14章 多态性

14.1 理解多态性

14.1.1 使用基类指针

14.1.2 调用继承的函数

14.1.3 虚函数

14.1.4 虚函数中的默认参数值

14.1.5 通过智能指针调用虚函数

14.1.6 通过引用调用虚函数

14.1.7 调用虚函数的基类版本

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

14.1.9 动态强制转换

14.1.10 转换引用

14.1.11 确定多态类型

14.2 多态性的成本

14.3 纯虚函数

14.3.1 抽象类

14.3.2 间接的抽象基类

14.4 通过指针释放对象

14.5 本章小结

14.6 练习

第15章 运行时错误和异常

15.1 处理错误

15.2 理解异常

15.2.1 抛出异常

15.2.2 异常处理过程

15.2.3 未处理的异常

15.2.4 导致抛出异常的代码

15.2.5 嵌套的try块

15.3 用类对象作为异常

15.3.1 匹配Catch处理程序和异常

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

15.3.3 重新抛出异常

15.3.4 捕获所有的异常

15.4 抛出异常的函数

15.4.1 函数try块

15.4.2 不抛出异常的函数

15.4.3 构造函数try块

15.4.4 异常和析构函数

15.5 标准库异常

15.5.1 异常类的定义

15.5.2 使用标准异常

15.6 本章小结

15.7 练习

第16章 类模板

16.1 理解类模板

16.2 定义类模板

16.2.1 模板参数

16.2.2 简单的类模板

16.2.3 定义类模板的函数成员

16.3 创建类模板的实例

16.4 类模板的静态成员

16.5 非类型的类模板参数

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

16.5.2 非类型参数的变元

16.5.3 把指针和数组用作非类型参数

16.6 模板参数的默认值

16.7 模板的显式实例化

16.8 特殊情形

16.8.1 在类模板中使用static_assert（）

16.8.2 定义类模板特化

16.8.3 部分模板特化

16.8.4 从多个部分特化中选择

16.9 类模板的友元

16.10 带有嵌套类的类模板

16.11 本章小结

16.12 练习

第17章 文件输入与输出

17.1 C＋＋中的输入输出

17.1.1 理解流

17.1.2 使用流的优点

17.2 流类

17.2.1 标准流对象

17.2.2 流的插入和提取操作

17.2.3 流操纵程序

17.3 文件流

17.3.1 在文本模式下写入文件

17.3.2 在文本模式下读取文件

17.4 设置流打开模式

17.5 未格式化的流操作

17.5.1 未格式化的流输入函数

17.5.2 未格式化的流输出函数

17.6 流输入输出中的错误

17.7 二进制模式中的流操作

17.8 文件的读写操作

17.9 字符串流

17.10 对象和流

17.10.1 给对象使用插入运算符

17.10.2 给对象使用提取运算符

17.10.3 二进制模式中的对象I/O

17.10.4 流中更复杂的对象

17.11 本章小结

17.12 练习