Beginning C++:The Complete Language

第1章 基本概念

1．1 编程语言

1．1．1 解释性的程序和编译性的程序的执行过程

1．1．2 库

1．2 为什么c++是一种强大的语言

1．3 一个简单的c++程序

1．4 名称

1．5 关键字

1. 6 c++语句和语句块

1．7 程序结构

1．8 从源文件中创建可执行文件

1．8．1 编译

1．8．2 链接

1．9 字符和字符集

1．9．1 字符编码

1．9．2 转义序列

1．9．3 空白

1．10 程序的注释

1．11 标准库

1．12 用c++编程

.1．13 本章小结

1．14 练习

第2章 基本数据类型和计算

2．1 数据和数据类型

2．2 进行简单的计算

2．2．1 整型字面量

2．2．2 二进制数

2．2．3 十六进制数

2．2．4 负的二进制数

2．2．5 十六进制的整型字面量

2．2．6 八进制的整型字面量

2．2．7 整数的算术运算

2．3 使用变量

2．4 整型变量

2．4．1 整型变量类型

2．4．2 内存中的整型变量

2．5 赋值运算符

2．5．1 多次赋值

2．5．2 修改变量的值

2．6 整数的递增和递减

2．7 const关键字

2．8 浮点数

2．8．1 浮点数的数据类型

2．8．2 使用浮点数值

2．9 使用字符

2．10 初始值的函数表示法

2．11 本章小结

2．12 练习

第3章 处理基本数据类型

3．1 混合的表达式

3．1．1 赋值和不同的类型

3．1．2 显式强制转换

3．1．3 老式的强制转换

3．2 确定类型

3．3 按位运算符

3．3．1 移位运算符

3．3．2 位模式下的逻辑运算

3．4 枚举数据类型

3．4．1 匿名枚举

3．4．2 在整型和枚举类型之间强制转换

3．5 数据类型的同义词

3．6 变量的生存期

3．6．1 自动变量

3．6．2 定位变量的声明

3．6．3 全局变量

3．6．4 静态变量

3．7 特殊的类型修饰符

3．8 声明外部变量

3．9 优先级和相关性

3．10 本章小结

3．11 练习

第4章 选择和决策

4．1 比较数据值

4．1．1 应用比较运算符

4．1．2 比较浮点数值

4．2 if语句

4．3 if-else语句

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 while循环

5．3 do-while循环

5．4 for循环

5．4．1 循环和变量作用域

5．4．2 用浮点数值控制for循环

5．4．3 使用更复杂的循环控制表达式

5．5 嵌套的循环

5．6 跳过循环迭代

5. 7 循环的中断

5．8 本章小结

5．9 练习

第6章 数组和字符串

6．1 数据数组

6．1．1 使用数组

6．1．2 初始化数组

6．1．3 字符数组

6．2 多维数组

6．2．1 初始化多维数组

6．2．2 多维字符数组

6．3 string类型

6．3．1 声明string对象

6．3．2 使用string对象

6．3．3 访问字符串中的字符

6．3．4 访问子字符串

6．3．5 比较字符串

6．3．6 搜索字符串

6．3．7 修改字符串

6．4 string类型的数组

6．5 本章小结

6．6 练习

第7章 指针

7．1 什么是指针

7．2 指针的声明

7．3 指针的初始化

7．4 常量指针和指向常量的指针

7．5 指针和数组

7．5．1 指针的算术运算

7．5．2 使用数组名的指针表示法

7．5．3 对多维数组使用指针

7．5．4 c样式字符串的操作

7．6 动态内存分配

7．6．1 自由存储区

7．6．2 运算符new和delete

7．6．3 数组的动态内存分配

7．6．4 动态内存分配的危险

7．6．5 转换指针

7．7 本章小结

7．8 练习

第8章 使用函数编程

8．1 程序的分解

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．5．3 从函数中返回新变量

8．6 内联函数

8．7 静态变量

8．8 本章小结

8．9 练习

第9章 函数

9．1 函数的重载

9．1．1 函数的签名

9．1．2 重载和指针参数

9．1．3 重载和引用参数

9．1．4 重载和const参数

9．1．5 重载和默认参数值

9．2 函数模板

9．2．1 显式指定模板参数

9．2．2 模板的说明

9．2．3 函数模板和重载

9．2．4 带有多个参数的模板

9．3 函数指针

9．3．1 声明函数指针

9．3．2 把函数作为参数传送

9．3．3 函数指针的数组

9．4 递归

9．5 本章小结

9．6 练习

第10章 程序文件和预处理器

10．1 使用程序文件

10．2 命名空间

10．2．1 全局命名空间

10．2．2 声明命名空间

10．2．3 隐式地限定名称

10．2．4 函数和命名空间

10．2．5 函数模板和命名空间

10．2．6 扩展命名空间

10．2．7 未指定名称的命名空间

10．2．8 命名空间的别名

10．2．9 嵌套的命名空间

10．3 预处理器

10．3．1 在程序中包含头文件

10．3．2 程序中的置换

10．3．3 宏置换

10．3．4 放在多行代码中的预处理器指令

10．3．5 把字符串作为宏参数

10．3．6 在宏表达式中连接参数

10．4 逻辑预处理器指令

10．4．1 逻辑#if指令

10．4．2 测试特定值的指令

10．4．3 多个代码选择块

10．4．4 标准的预处理器宏

10．4．5 #error和#pragma指令

10．5 调试方法

10．5．1 集成调试器

10．5．2 调试中的预处理器

10．5．3 使用assert宏

10．6 本章小结

10．7 练习

第11章 创建自己的数据类型

11．1 对象的概念

11．2 c++中的结构

11．2．1 理解结构

11．2．2 定义结构类型

11．2．3 初始化结构变量

11．2．4 访问结构变量的成员

11．2．5 对结构使用指针

11．3 联合

11．3．1 声明联合

11．3．2 匿名联合

11．4 更复杂的结构

11．5 本章小结

11．6 练习

第12章 类

12．1 类和面向对象编程

12．1．1 封装

12．1．2 继承

12．1．3 多态性

12．1．4 术语

12．2 定义类

12．3 构造函数

12．3．1 把构造函数的定义放在类的外部

12．3．2 默认的构造函数

12．3．3 默认的初始化值

12．3．4 在构造函数中使用初始化列表

12．3．5 使用explicit关键字

12．4 类的私有成员

12．4．1 访问私有类成员

12．4．2 默认的副本构造函数

12．5 友元

12．5．1 类的友元函数

12．5．2 友元类

12．6 this指针

12．7 const对象和const成员函数

12．7．1 类中的mutable数据成员

12．7．2 常量的强制转换

12．8 类的对象数组

12．9 类对象的大小

12．10 类的静态成员

12．10．1 类的静态数据成员

12．10．2 类的静态成员函数

12．11 本章小结

12．12 练习

第13章 类的操作

13．1 类对象的指针和引用

13．2 指针作为数据成员

13．2．1 定义package类

13．2．2 定义truckload类

13．2．3 实现truckload类

13．3 控制对类的访问

13．4 副本构造函数的重要性

13．5 对象内部的动态内存分配

13．5．1 析构函数

13．5．2 默认的析构函数

13．5．3 实现析构函数

13．6 类的引用

13．7 本章小结

13．8 练习

第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．1．12 智能指针

14．1．13 重载运算符new和delete

14．2 本章小结

14．3 练习

第15章 继承

15．1 类和面向对象编程

15．2 类的继承

15．2．1 继承和聚合

15．2．2 从基类中派生新类

15．3 继承下的访问控制

15．4 把类的成员声明为protected

15．5 派生类成员的访问级别

15．6 派生类中的构造函数操作

15．7 继承中的析构函数

15．8 重复的成员名

15．9 多重继承

15．9．1 多个基类

15．9．2 继承成员的模糊性

15．9．3 重复的继承

15．9．4 虚基类

15．10 在相关的类类型之间转换

15．11 本章小结

15．12 练习

第16章 虚函数和多态性

16．1 理解多态性

16．1．1 使用基类指针

16．1．2 调用继承的函数

16．1．3虚函数

16．1．4 虚函数中的默认参数值

16．1．5 通过引用来调用虚函数

16．1．6 调用虚函数的基类版本

16．1．7 在指针和类对象之间转换

16．1．8 动态强制转换

16．2 多态性的成本

16．3 纯虚函数

16．3．1 抽象类

16．3．2 间接的抽象基类

16．4 通过指针释放对象

16．5 在运行期间标识类型

16．6 类成员的指针

16．6．1 数据成员指针

16．6．2 成员函数指针

16．7 本章小结

16．8 练习

第17章 程序错误和异常处理

17．1 处理错误

17．2 理解异常

17．2．1 抛出异常

17．2．2 导致抛出异常的代码

17．2．3 嵌套的try块

17．3 用类对象作为异常

17．3．1 匹配catch处理程序和异常

17．3．2 用基类处理程序捕获派生类异常

17．3．3 重新抛出异常

17．3．4 捕获所有的异常

17．4 抛出异常的函数

17．4．1 函数try块

17．4．2 在构造函数中抛出异常

17．4．3 异常和析构函数

17．5 标准库异常

17．5．1 标准库异常类

17．5．2 使用标准异常

17．6 本章小结

17．7 练习

第18章 类模板

18．1 理解类模板

18．2 定义类模板

18．2．1 模板参数

18．2．2 简单的类模板

18．2．3 创建类模板的实例

18．2．4 类模板的静态成员

18．2．5 非类型的类模板参数

18．2．6 非类型参数示例

18．2．7 默认的模板参数值

18．3 模板的显式实例化

18．4 类模板的友元

18．5 特殊情形

18．6 带有嵌套类的类模板

18．7 更高级的类模板

18．8 本章小结

18．9 练习

第19章 输入输出操作

19．1 c++中的输入输出

19．2 流类

19．2．1 标准流

19．2．2 流的插入和提取操作

19．2．3 流操纵程序

19．3 文件流

19．3．1 写入文件

19．3．2 读取文件

19．3．3 设置文件打开模式

19．4 未格式化的流操作

19．4．1 未格式化的流输入函数

19．4．2 未格式化的流输出函数

19．5 流输入输出中的错误

19．6 使用二进制模式流操作

19．7 流上的读写操作

19．8 字符串流

19．9 对象和流

19．9．1 重载类对象的插入运算符

19．9．2 重载类对象的提取运算符

19．9．3 流中更复杂的对象

19．10 本章小结

19．11 练习

第20章 标准模板库

20．1 stl架构简介

20．2 使用vector容器

20．2．1 vector容器的基本操作

20．2．2 使用vector容器进行数组操作

20．2．3 istream_iterator迭代器

20．3 理解迭代器

20．3．1 给算法传送迭代器

20．3．2 模拟istream_operator和ostream_operator

20．3．3 迭代器的要求

20．3．4 修订后的integer迭代器

20．3．5 输入和输出迭代器

20．4 存储空间管理一瞥

20．4．1 account帮助类

20．4．2 stl元素需求和理想的bean

20．4．3 确定vector的大小和vector存储空间的管理

20．5 list容器

20．6 关联map容器

20. 7 性能和规范

20．8 本章小结

20．9 练习

附录a ascii码

附录b c++关键字

附录c 标准库头文件

c．1 语言支持

c．2 输入／输出

c．3 诊断

c．4 一般工具

c．5 字符串

c．6 容器

c．7 迭代器支持

c．8 一般用途的算法

c．9 数值操作

c．10 本地化

附录d 运算符的优先级和相关性

附录e 项目示例

e．1 提纲

e．2 开发人员应注意的问题

e．2．1 person类

e．2．2 student和teacher派生类

e．2．3 容器

e．2．4 保存和恢复数据

e．3 小结