第0章 致读者

0.1 本书结构

0.1.1 一般方法

0.1.2 简单练习、习题等

0.1.3 进阶学习

0.2 讲授和学习本书的方法

0.2.1 本书内容顺序的安排

0.2.2 程序设计和程序设计语言

0.2.3 可移植性

0.3 程序设计和计算机科学

0.4 创造性和问题求解

0.5 反馈方法

0.6 参考文献

0.7 作者简介

第1章 计算机、人与程序设计

1.1 介绍

1.2 软件

1.3 人

1.4 计算机科学

1.5 计算机已无处不在

1.5.1 有屏幕和没有屏幕

1.5.2 船舶

1.5.3 电信

1.5.4 医疗

1.5.5 信息领域

1.5.6 一种垂直的视角

1.5.7 与C＋＋程序设计有何联系

1.6 程序员的理想

第一部分 基本知识

第2章 Hello,World!

2.1 程序

2.2 经典的第一个程序

2.3 编译

2.4 链接

2.5 编程环境

第3章 对象、类型和值

3.1 输入

3.2 变量

3.3 输入和类型

3.4 运算和运算符

3.5 赋值和初始化

3.5.1 实例：删除重复单词

3.6 组合赋值运算符

3.6.1 实例：重复单词统计

3.7 命名

3.8 类型和对象

3.9 类型安全

3.9.1 安全类型转换

3.9.2 不安全类型转换

第4章 计算

4.1 计算

4.2 目标和工具

4.3 表达式

4.3.1 常量表达式

4.3.2 运算符

4.3.3 类型转换

4.4 语句

4.4.1 选择语句

4.4.2 循环语句

4.5 函数

4.5.1 使用函数的原因

4.5.2 函数声明

4.6 向量

4.6.1 向量空间增长

4.6.2 一个数值计算的例子

4.6.3 一个文本处理的例子

4.7 语言特性

第5章 错误

5.1 介绍

5.2 错误的来源

5.3 编译时错误

5.3.1 语法错误

5.3.2 类型错误

5.3.3 警告

5.4 连接时错误

5.5 运行时错误

5.5.1 调用者处理错误

5.5.2 被调用者处理错误

5.5.3 报告错误

5.6 异常

5.6.1 错误参数

5.6.2 范围错误

5.6.3 输入错误

5.6.4 截断错误

5.7 逻辑错误

5.8 估计

5.9 调试

5.9.1 实用调试技术

5.10 前置条件和后置条件

5.10.1 后置条件

5.11 测试

第6章 编写一个程序

6.1 一个问题

6.2 对问题的思考

6.2.1 程序设计的几个阶段

6.2.2 策略

6.3 回到计算器问题

6.3.1 第一步尝试

6.3.2 单词

6.3.3 实现单词

6.3.4 使用单词

6.3.5 重新开始

6.4 文法

6.4.1 英文文法

6.4.2 设计一个文法

6.5 将文法转换为程序

6.5.1 实现文法规则

6.5.2 表达式

6.5.3 项

6.5.4 基本表达式

6.6 试验第一个版本

6.7 试验第二个版本

6.8 单词流

6.8.1 实现Token_stream

6.8.2 读单词

6.8.3 读数值

6.9 程序结构

第7章 完成一个程序

7.1 介绍

7.2 输入和输出

7.3 错误处理

7.4 处理负数

7.5 模运算：％

7.6 清理代码

7.6.1 符号常量

7.6.2 使用函数

7.6.3 代码格式

7.6.4 注释

7.7 错误恢复

7.8 变量

7.8.1 变量和定义

7.8.2 引入单词name

7.8.3 预定义名字

7.8.4 我们到达目的地了吗

第8章 函数相关的技术细节

8.1 技术细节

8.2 声明和定义

8.2.1 声明的类别

8.2.2 变量和常量声明

8.2.3 默认初始化

8.3 头文件

8.4 作用域

8.5 函数调用和返回

8.5.1 声明参数和返回类型

8.5.2 返回一个值

8.5.3 传值参数

8.5.4 传常量引用参数

8.5.5 传引用参数

8.5.6 传值与传引用的对比

8.5.7 参数检查和转换

8.5.8 实现函数调用

8.6 求值顺序

8.6.1 表达式求值

8.6.2 全局初始化

8.7 名字空间

8.7.1 using声明和using指令

第9章 类相关的技术细节

9.1 用户自定义类型

9.2 类和成员

9.3 接口和实现

9.4 演化一个类

9.4.1 结构和函数

9.4.2 成员函数和构造函数

9.4.3 保持细节私有性

9.4.4 定义成员函数

9.4.5 引用当前对象

9.4.6 报告错误

9.5 枚举类型

9.6 运算符重载

9.7 类接口

9.7.1 参数类型

9.7.2 拷贝

9.7.3 默认构造函数

9.7.4 const成员函数

9.7.5 类成员和“辅助函数”

9.8 Date类

第二部分 输入和输出

第10章 输入／输出流

10.1 输入和输出

10.2 I/O流模型

10.3 文件

10.4 打开文件

10.5 读写文件

10.6 I/O错误处理

10.7 读取单个值

10.7.1 将程序分解为易管理的子模块

10.7.2 将人机对话从函数中分离

10.8 用户自定义输出操作符

10.9 用户自定义输入操作符

10.10 一个标准的输入循环

10.11 读取结构化的文件

10.11.1 内存表示

10.11.2 读取结构化的值

10.11.3 改变表示方法

第11章 定制输入／输出

11.1 有规律的和无规律的输入和输出

11.2 格式化输出

11.2.1 输出整数

11.2.2 输入整数

11.2.3 输出浮点数

11.2.4 精度

11.2.5 域

11.3 文件打开和定位

11.3.1 文件打开模式

11.3.2 二进制文件

11.3.3 在文件中定位

11.4 字符串流

11.5 面向行的输入

11.6 字符分类

11.7 使用非标准分隔符

11.8 还有很多未讨论的内容

第12章 一个显示模型

12.1 为什么要使用图形用户界面

12.2 一个显示模型

12.3 第一个例子

12.4 使用GUI库

12.5 坐标系

12.6 形状

12.7 使用形状类

12.7.1 图形头文件和主函数

12.7.2 一个几乎空白的窗口

12.7.3 坐标轴

12.7.4 绘制函数图

12.7.5 Polygon

12.7.6 Rectangle

12.7.7 填充

12.7.8 文本

12.7.9 图片

12.7.10 还有很多未讨论的内容

12.8 让图形程序运行起来

12.8.1 源文件

第13章 图形类

13.1 图形类概览

13.2 Point和Line

13.3 Lines

13.4 Color

13.5 Line_style

13.6 Open_polyline

13.7 Closed_polyline

13.8 Polygon

13.9 Rectangle

13.10 管理未命名对象

13.11 Text

13.12 Circle

13.13 Ellipse

13.14 Marked_polyline

13.15 Marks

13.16 Mark

13.17 Image

第14章 设计图形类

14.1 设计原则

14.1.1 类型

14.1.2 操作

14.1.3 命名

14.1.4 可变性

14.2 Shape类

14.2.1 一个抽象类

14.2.2 访问控制

14.2.3 绘制形状

14.2.4 拷贝和可变性

14.3 基类和派生类

14.3.1 对象布局

14.3.2 类的派生和虚函数定义

14.3.3 覆盖

14.3.4 访问

14.3.5 纯虚函数

14.4 面向对象程序设计的好处

第15章 绘制函数图和数据图

15.1 介绍

15.2 绘制简单函数图

15.3 Function类

15.3.1 默认参数

15.3.2 更多的例子

15.4 Axis类

15.5 近似

15.6 绘制数据图

15.6.1 读取文件

15.6.2 一般布局

15.6.3 数据比例

15.6.4 构造数据图

第16章 图形用户界面

16.1 用户界面的选择

16.2 “Next”按钮

16.3 一个简单的窗口

16.3.1 回调函数

16.3.2 等待循环

16.4 Button和其他Widget

16.4.1 Widget

16.4.2 Button

16.4.3 In_box和Out_box

16.4.4 Menu

16.5 一个实例

16.6 控制流的反转

16.7 添加菜单

16.8 调试GUI代码

第三部分 数据结构和算法

第17章 向量和自由空间

17.1 介绍

17.2 向量的基本知识

17.3 内存、地址和指针

17.3.1 运算符sizeof

17.4 自由空间和指针

17.4.1 自由空间分配

17.4.2 通过指针访问数据

17.4.3 指针范围

17.4.4 初始化

17.4.5 空指针

17.4.6 自由空间释放

17.5 析构函数

17.5.1 生成的析构函数

17.5.2 析构函数和自由空间

17.6 访问向量元素

17.7 指向类对象的指针

17.8 类型混用：无类型指针和指针类型转换

17.9 指针和引用

17.9.1 指针参数和引用参数

17.9.2 指针、引用和继承

17.9.3 实例：列表

17.9.4 列表的操作

17.9.5 列表的使用

17.10 this指针

17.10.1 关于Link使用的更多讨论

第18章 向量和数组

18.1 介绍

18.2 拷贝

18.2.1 拷贝构造函数

18.2.2 拷贝赋值

18.2.3 拷贝术语

18.3 必要的操作

18.3.1 显示构造函数

18.3.2 调试构造函数与析构函数

18.4 访问向量元素

18.4.1 对const对象重载运算符

18.5 数组

18.5.1 指向数组元素的指针

18.5.2 指针和数组

18.5.3 数组初始化

18.5.4 指针问题

18.6 实例：回文

18.6.1 使用string实现回文

18.6.2 使用数组实现回文

18.6.3 使用指针实现回文

第19章 向量、模板和异常

19.1 问题

19.2 改变向量大小

19.2.1 方法描述

19.2.2 reserve和capacity

19.2.3 resize

19.2.4 push_back

19.2.5 赋值

19.2.6 到现在为止我们设计的vector类

19.3 模板

19.3.1 类型作为模板参数

19.3.2 泛型编程

19.3.3 容器和继承

19.3.4 整数作为模板参数

19.3.5 模板参数推导

19.3.6 一般化vector类

19.4 范围检查和异常

19.4.1 附加讨论：设计上的考虑

19.4.2 使用宏

19.5 资源和异常

19.5.1 潜在的资源管理问题

19.5.2 资源获取即初始化

19.5.3 保证

19.5.4 auto_ptr

19.5.5 vector类的RAII

第20章 容器和迭代器

20.1 存储和处理数据

20.1.1 处理数据

20.1.2 一般化代码

20.2 STL建议

20.3 序列和迭代器

20.3.1 回到实例

20.4 链表

20.4.1 列表操作

20.4.2 迭代

20.5 再次一般化vector

20.6 实例：一个简单的文本编辑器

20.6.1 处理行

20.6.2 迭代

20.7 vector、list和string

20.7.1 insert和erase

20.8 调整vector类达到STL版本的功能

20.9 调整内置数组达到STL版本的功能

20.10 容器概览

20.10.1 迭代器类别

第21章 算法和映射

21.1 标准库中的算法

21.2 最简单的算法：find

21.2.1 一些一般的应用

21.3 通用搜索算法：find_if()

21.4 函数对象

21.4.1 函数对象的抽象视图

21.4.2 类成员上的谓词

21.5 数值算法

21.5.1 累积

21.5.2 一般化accumulate()

21.5.3 内积

21.5.4 一般化inner_product()

21.6 关联容器

21.6.1 映射

21.6.2 map概览

21.6.3 另一个map实例

21.6.4 unordered_map

21.6.5 集合

21.7 拷贝操作

21.7.1 拷贝

21.7.2 流迭代器

21.7.3 使用集合保持顺序

21.7.4 copy_if

21.8 排序和搜索

第四部分 拓宽视野

第22章 理念和历史

22.1 历史、理念和专业水平

22.1.1 程序设计语言的目标和哲学

22.1.2 编程理念

22.1.3 风格／范型

22.2 程序设计语言历史概览

22.2.1 最早的程序语言

22.2.2 现代程序设计语言的起源

22.2.3 Algol家族

22.2.4 Simula

22.2.5 C

22.2.6 C＋＋

22.2.7 今天的程序设计语言

22.2.8 参考资源

第23章 文本处理

23.1 文本

23.2 字符串

23.3 I/O流

23.4 映射

23.4.1 实现细节

23.5 一个问题

23.6 正则表达式的思想

23.7 用正则表达式进行搜索

23.8 正则表达式语法

23.8.1 字符和特殊字符

23.8.2 字符集

23.8.3 重复

23.8.4 子模式

23.8.5 可选项

23.8.6 字符集和范围

23.8.7 正则表达式错误

23.9 与正则表达式进行模式匹配

23.10 参考文献

第24章 数值计算

24.1 介绍

24.2 大小、精度和溢出

24.2.1 数值限制

24.3 数组

24.4 C风格的多维数组

24.5 Matrix库

24.5.1 矩阵的维和矩阵访问

24.5.2 一维矩阵

24.5.3 二维矩阵

24.5.4 矩阵I/O

24.5.5 三维矩阵

24.6 实例：求解线性方程组

24.6.1 经典的高斯消去法

24.6.2 选取主元

24.6.3 测试

24.7 随机数

24.8 标准数学函数

24.9 复数

24.10 参考文献

第25章 嵌入式系统程序设计

25.1 嵌入式系统

25.2 基本概念

25.2.1 可预测性

25.2.2 理想

25.2.3 生活在故障中

25.3 内存管理

25.3.1 动态内存分配存在的问题

25.3.2 动态内存分配的替代方法

25.3.3 存储池实例

25.3.4 栈实例

25.4 地址、指针和数组

25.4.1 未经检查的类型转换

25.4.2 一个问题：不正常的接口

25.4.3 解决方案：接口类

25.4.4 继承和容器

25.5 位、字节和字

25.5.1 位和位运算

25.5.2 bitset

25.5.3 有符号数和无符号数

25.5.4 位运算

25.5.5 位域

25.5.6 实例：简单加密

25.6 编码规范

25.6.1 编码规范应该是怎样的

25.6.2 编码原则实例

25.6.3 实际编码规范

第26章 测试

26.1 我们想要什么

26.1.1 说明

26.2 程序正确性证明

26.3 测试

26.3.1 回归测试

26.3.2 单元测试

26.3.3 算法和非算法

26.3.4 系统测试

26.3.5 测试类

26.3.6 寻找不成立的假设

26.4 测试方案设计

26.5 调试

26.6 性能

26.6.1 计时

26.7 参考文献

第27章 C语言

27.1 C和C＋＋：兄弟

27.1.1 C/C＋＋兼容性

27.1.2 C不支持的C＋＋特性

27.1.3 C标准库

27.2 函数

27.2.1 不支持函数名重载

27.2.2 函数参数类型检查

27.2.3 函数定义

27.2.4 C＋＋调用C和C调用C＋＋

27.2.5 函数指针

27.3 小的语言差异

27.3.1 结构标签名字空间

27.3.2 关键字

27.3.3 定义

27.3.4 C风格类型转换

27.3.5 void＊的转换

27.3.6 枚举

27.3.7 名字空间

27.4 动态内存分配

27.5 C风格字符串

27.5.1 C风格字符串和const

27.5.2 字节操作

27.5.3 实例：strcpy()

27.5.4 一个风格问题

27.6 输入／输出：stdio

27.6.1 输出

27.6.2 输入

27.6.3 文件

27.7 常量和宏

27.8 宏

27.8.1 类函数宏

27.8.2 语法宏

27.8.3 条件编译

27.9 实例：侵入式容器

术语表

参考书目