《标准C++开发入门与编程实践》准备第二版，请提建议！

《标准C++开发入门与编程实践》 

《标准C++开发入门与编程实践》准备第二版，请提建议！大家都希望在哪些方面可以有所深入和侧重？

第1篇 C++快速浏览
　第1章 了解C++语言
　　1.1 编程语言
　　　1.1.1 机器语言
　　　1.1.2 汇编语言
　　　1.1.3 高级语言
　　1.2 C++发展简史
　　1.3 C++开发环境
　　　1.3.1 C++编译器
　　　1.3.2 C++标准与编译器
　　　1.3.3 C++开发环境
　　　1.3.4 开发环境的选择
　第2章 计算机的数值表示
　　2.1 进制系统
　　　2.1.1 十进制
　　　2.1.2 二进制
　　　2.1.3 八进制和十六进制
　　2.2 数值的表示
　　　2.2.1 整数的表示
　　　2.2.2 负数的表示

　2.2.3 整数的表示范围
　　　2.2.4 浮点数的表示
　　　2.2.5 观察数值的二进制表示*
　　2.3 字符的表示
　　　2.3.1 ASCII码
　　　2.3.2 汉字的编码
　　　2.3.3 UNICODE编码
　　　2.3.4 观察字符的二进制表示*
　　　2.3.5 字符与字体
　　　2.3.6 键盘与输入法
　第3章 初识C++程序
　　3.1 开始C++编程
　　　3.1.1 C++程序的开发流程
　　　3.1.2 文件与工程（项目）
　　3.2 在Dev-C++中开发HelloWorld
　　　3.2.1 编辑HelloWorld
　　　3.2.2 编译连接HelloWorld
　　　3.2.3 运行HelloWorld
　　3.3 在VC 2003中开发HelloWorld
　　　3.3.1 编辑HelloWorld
　　　3.3.2 编译连接Hello World
　　　3.3.3 运行HelloWorld
　　3.4 可能遇到的问题
　　　3.5.1 main函数
　　　3.5.2 函数
　　　3.5.3 对象
　　　3.5.4 头文件
　　　3.5.5 名字空间
　　　3.5.6 标准输入输出
　　　3.5.7 编译器的行为
　　3.5 理解HelloWorld
第2篇 C++数据表达
　第4章 C++基础语法
　　4.1 理解c=2?r
　　4.2 注释
　　4.3 标识符
　　　4.3.1 命名规则
　　　4.3.2 关键字
　　4.4 数与类型
　　4.5 基本类型
　　　4.5.1 整型
　　　4.5.2 浮点型
　　　4.5.3 布尔型
　　　4.5.4 字符型
　　　4.5.5 基本类型的字节长度*
　　4.6 字面常量
　　　4.6.1 整型常量
　　　4.6.2 浮点型常量
　　　4.6.3 布尔型常量
　　　4.6.4 字符型常量
　　　4.6.5 字符串常量
　　　4.6.6 字面常量的类型*
　　　4.6.7 变量
　　4.7 语句
　　　4.7.1 表达式
　　　4.7.2 语句
　　　4.7.3 声明语句
　　　4.7.4 赋值语句
　　　4.7.5 初始化语句
　　　4.7.6 使用调试器观察变量值*
　　4.8 操作符
　　　4.8.1 赋值操作符 　　
　　　4.8.2 算术操作符
　　　4.8.3 关系操作符
　　　4.8.4 逻辑操作符
　　　4.8.5 条件操作符
　　　4.8.6 位操作符
　　　4.8.7 观察二进制位操作*
　　　4.8.8 复合赋值操作符
　　　4.8.9 逗号操作符
　　　4.8.10 sizeof操作符
　　　4.8.11 typeid操作符
　　　4.8.12 操作符的优先级
　　4.9 类型转换
　　　4.9.1 隐式转换
　　　4.9.2 显式转换
　　　4.9.3 算术转换*
　第5章 数组与字符串
　　5.1 数组
　　　5.1.1 数组的概念
　　　5.1.2 内存中的数组*
　　　5.1.3 数组的初始化
　　　5.1.4 数组元素的访问
　　　5.1.5 安全使用数组下标*
　　　5.1.6 **数组
　　5.2 字符串
　　　5.2.1 传统的字符串
　　　5.2.2 安全的使用字符串*
　　　5.2.3 std::string
　第6章 指针与引用
　　6.1 指针
　　　6.1.1 指针的概念
　　　6.1.2 取址操作符
　　　6.1.3 取值操作符
　　　6.1.4 深入理解指针*
　　　6.1.5 指针的比较
　　　6.1.6 指针的加减
　　　6.1.7 理解指针的运算*
　　　6.1.8 数组与指针
　　　6.1.9 指针的指针
　　　6.1.10 指针数组
　　6.2 引用
　　　6.2.1 引用的概念
　　　6.2.2 理解引用*
　　6.3 动态内存分配
　　　6.3.1 new
　　　6.3.2 delete
　　　6.3.3 数组的内存分配
　第7章 自定义数据类型
　　7.1 结构
　　　7.1.1 结构的定义
　　　7.1.2 定义结构变量
　　　7.1.3 结构的数据成员
　　　7.1.4 结构成员的引用
　　　7.1.5 结构的初始化
　　　7.1.6 位域
　　7.2 联合
　　　7.2.1 联合的定义
　　　7.2.2 使用联合
　　7.3 枚举
　　　7.3.1 枚举定义
　　　7.3.2 枚举与int
　　7.4 typedef
　　7.5 数据类型修饰符
　　　7.5.1 const
　　　7.5.2 volatile
第3篇 C++过程设计
　第8章 C++流程控制
　　8.1 判断
　　　8.1.1 if
　　　8.1.2 语句块*
　　　8.1.3 if…else
　　　8.1.4 if…else if…else
　　　8.1.5 流程图*
　　8.2 分支
　　8.3 循环
　　　8.3.1 while
　　　8.3.2 do…while
　　　8.3.3 for
　　8.4 跳转语句
　　　8.4.1 嵌套循环
　　　8.4.2 使用break中止循环
　　　8.4.3 使用break中止分支
　　　8.4.4 continue
　　　8.4.5 goto
　　　8.4.6 合理使用goto语句*
　第9章 C++函数
　　9.1 函数
　　　9.1.1 函数
　　　9.1.2 函数调用
　　　9.1.3 使用调试器观察函数的调用*
　　　9.1.4 函数参数
　　　9.1.5 返回值
　　9.2 函数原型
　　　9.2.1 函数原型（function prototype）
　　　9.2.2 main()函数
　　　9.2.3 定义带参数的main()函数*
　　　9.2.4 默认参数
　　　9.2.5　可变参数*
　　　9.2.6 内联函数
　　9.3 函数重载
　　　9.3.1 函数的重载
　　　9.3.2 重载函数的调用
　　　9.3.3 安全连接
　　　9.3.4 名字重组*
　　9.4 递归函数
　　　9.4.1 递归函数
　　　9.4.2 使用调试器观察函数的递归调用*
　　9.5 函数与指针
　　　9.5.1 指向函数的指针
　　　9.5.2 理解函数指针*
　　　9.5.3 函数与值传递
　第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 C++预定义宏
　　10.3 条件编译指令
　　　10.3.1 #if…#endif
　　　10.3.2 #else
　　　10.3.3 #elif
　　　10.3.4 #if defined和#if !defined
　　　10.3.5 #ifdef和#ifndef
　　10.4 文件包含指令
　　　10.4.1 #include
　　　10.4.2 合理使用头文件
　　10.5 其他标准指令
　　　10.5.1 #error
　　　10.5.2 #line
　　　10.5.3 #pragma
第4篇 C++面向对象编程
　第11章 C++的类
　　11.1 类与对象
　　　11.1.1 对象
　　　11.1.2 类
　　11.2 类的设计
　　　11.2.1 类的定义
　　　11.2.2 对象的定义
　　　11.2.3 数据成员的访问
　　　11.2.4 成员访问控制
　　　11.2.5 成员函数
　　　11.2.6 内联成员函数
　　　11.2.7 成员函数的重载
　　　11.2.8 this指针
　　　11.2.9 内存中的类*
　　11.3 类的讨论
　　　11.3.1 类与结构
　　　11.3.2 抽象性
　　　11.3.3 封装性
　　11.4　类的组合
　　　11.4.1 使用类的组合
　　　11.4.2 类的声明
　第12章 类的特殊函数
　　12.1 构造函数
　　　12.1.1 构造函数（constructor）
　　　12.1.2 带参数的构造函数
　　　12.1.3 初始值列表
　　12.2 成员初始值列表
　　　12.2.1 使用成员初始值列表
　　　12.2.2 对象成员初始化
　　12.3 析构函数
　　　12.3.1 析构函数的定义
　　　12.3.2 对象成员的构造与析构*
　　12.4 特殊构造函数
　　　12.4.1 转换构造函数
　　　12.4.2 explicit
　　　12.4.3 拷贝构造函数
　　12.5 操作符函数
　　　12.5.1 操作符重载
　　　12.5.2 一元操作符重载
　　　12.5.3 二元操作符重载
　　　12.5.4 全局操作符的重载
　　　12.5.5 可重载的操作符
　　　12.5.6 类型转换函数
　　12.6 const与mutable
　　　12.6.1 const
　　　12.6.2 mutable
　　12.7 友元
　　　12.7.1 声明某个函数为友元
　　　12.7.2 声明某个类的成员函数为友元
　　　12.7.3 声明某个类为友元
　第13章 继承
　　13.1 类的继承
　　　13.1.1 继承的概念
　　　13.1.2 类的继承
　　　13.1.3 内存中的派生类*
　　　13.1.4 protected
　　　13.1.5 基类访问控制
　　13.2 构造与析构
　　　13.2.1 派生类的构造
　　　13.2.2 基类的初始化
　　　13.2.3 默认构造函数
　　　13.2.4 派生类的析构
　　13.3 名字隐藏
　　　13.3.1 数据成员的隐藏
　　　13.3.2 成员函数的隐藏
　　　13.3.3 理解隐藏
　第14章 多态性
　　14.1 类型转换
　　　14.1.1 向上转换
　　　14.1.2 向下转换
　　14.2 虚函数与多态
　　　14.2.1 类型转换带来的问题
　　　14.2.2 虚函数
　　　14.2.3 虚函数的填充*
　　　14.2.4 多态性
　　　14.2.5 虚析构函数
　　　14.2.6 纯虚函数
　　　14.2.7 抽象类
　　14.3 多级继承
　　　14.3.1 多级继承的使用
　　　14.3.2 虚函数的多次填充*
　　14.4 多继承
　　　14.4.1 多继承的使用
　　　14.4.2 多继承带来的问题
　　　14.4.3 虚拟继承
第5篇 C++高级特性
　第15章 模板
　　15.1 函数模板
　　　15.1.1 函数模板的概念
　　　15.1.2 模板参数与函数参数
　　　15.1.3 函数模板的实例化
　　　15.1.4 函数模板的重载
　　　15.1.5 函数模板的特化*
　　15.2 类模板
　　　15.2.1 类模板的概念
　　　15.2.2 类模板的成员函数
　　　15.2.3 包含多个参数的类模板
　　　15.2.4 类模板的默认参数
　第16章 C++异常处理
　　16.1 传统的错误处理
　　16.2 抛出异常
　　16.3 捕获异常
　　　16.3.1 使用catch捕获异常
　　　16.3.2 捕获不同类型的异常
　　　16.3.3 捕获所有的异常
　　　16.3.4 在catch块抛出异常
　　　16.3.5 未捕获的异常
　　　16.3.6 定制terminate()的行为*
　　16.4 对抛出异常的声明
　第17章 名字空间与域
　　17.1 名字空间
　　　17.1.1 名字空间定义
　　　17.1.2　using声明
　　　17.1.3 using指令
　　　17.1.4 名字空间的别名
　　17.2 作用域
　　17.3 局部作用域
　　　17.3.1 局部作用域的概念
　　　17.3.2 for语句的作用域
　　　17.3.3 case语句块的作用域
　　　17.3.4 函数的作用域
　　17.4 局部变量的存储类型
　　　17.4.1 自动存储类型
　　　17.4.2 寄存器存储类型
　　　17.4.3 静态存储类型
　　17.5 名字空间域
　　　17.5.1 全局域
　　　17.5.2 外部存储类型
　　　17.5.3 文件域
　　　17.5.4 名字空间域
　　17.6 类域
　　　17.6.1 类域的概念
　　　17.6.2 static数据成员
　　　17.6.3 static成员函数
　　17.7 作用域的嵌套
　　　17.7.1 语句块的嵌套
　　　17.7.2 名字空间的嵌套
　　　17.7.3 类的嵌套
　　　17.7.4 在语句块中定义类
　　　17.7.5 嵌套带来的隐藏
　　17.8 对象的生命周期
　第18章 运行时类型信息
　　18.1 动态类型的获取
　　　18.1.1 typeid关键字
　　　18.1.2 type_info
　　　18.1.3 打开RTTI开关*
　　　18.1.4 获取对象的动态类型
　　18.2 C++风格的类型转换
　　　18.2.1 动态类型转换dynamic_cast
　　　18.2.2 静态类型转换static_cast
　　　18.2.3 再解释类型转换reinterpret_cast
　　　18.2.4 常类型转换const_cast
第6篇 C++编程实践
　第19章 C++标准库
　　19.1 C++标准库的组成
　　19.2 字符串库[string]
　　　19.2.1 字符串的构造与赋值
　　　19.2.2 字符串的连接
　　　19.2.3 字符串的比较
　　　19.2.4 字符串的下标
　　　19.2.5 子串
　　　19.2.6 字符串的查找
　　　19.2.7 string与C-style字符串
　　　19.2.8 空字符串
　　19.3 复数类[complex]
　　　19.3.1 复数的构造
　　　19.3.2 复数的四则运算
　　　19.3.3 复数的操作函数
　　19.4 异常类[stdexcept]
　　19.5 C标准库
　　　19.5.1 assert宏
　　　19.5.2 类型函数
　　　19.5.3 数学函数
　　　19.5.4 类型转换函数
　　　19.5.5 随机数函数
　　　19.5.6 可变参数处理
　　　19.5.7 内存操作函数
　　　19.5.8 系统控制函数
　　　19.5.9 字符串处理函数
　　　19.5.10 时间处理函数
　第20章 C++流
　　20.1 输入输出流[iostream]
　　　20.1.1 输入输出流
　　　20.1.2 流操作符
　　　20.1.3 格式化输出函数
　　　20.1.4 格式操纵符
　　　20.1.5 流的输出
　　　20.1.6 缓冲输出
　　　20.1.7 流的输入
　　　20.1.8 状态标志*
　　20.2 标准输入输出流
　　20.3 文件流[fstream]
　　　20.3.1 文件的打开和关闭
　　　20.3.2 二进制输入输出
　　　20.3.3 定位文件位置
　　20.4 字符串流[sstream]
　　　20.4.1 ostringstream
　　　20.4.2 istringstream
　　　20.4.3 stringstream
　第21章 STL容器
　　21.1 标准模板库
　　　21.1.1 STL的概念
　　　21.1.2 STL的组成
　　　21.1.3 STL的使用实例
　　21.2 容器
　　　21.2.1 STL容器
　　　21.2.2 容器的模板参数
　　　21.2.3 容器的比较
　　　21.2.4 容器的赋值和交换
　　　21.2.5 operator []
　　　21.2.6 指示器的获取
　　　21.2.7 元素的迭代访问
　　　21.2.8 容器的尺寸
　　21.3 向量
　　　21.3.1 向量的构造
　　　21.3.2 向量元素的访问
　　　21.3.3 向量元素的添加
　　　21.3.4 向量元素的删除
　　21.4 列表
　　　21.4.1 列表的构造
　　　21.4.2 列表元素的访问
　　　21.4.3 列表元素的添加
　　　21.4.4 列表元素的删除
　　21.5 双端队列
　　　21.5.1 双端队列的构造
　　　21.5.2 双端队列元素的访问
　　　21.5.3 双端队列元素的添加
　　　21.5.4 双端队列元素的删除
　　21.6 容器适配器
　　　21.6.1 栈
　　　21.6.2 队列
　　　21.6.3 优先级队列
　　21.7 映射
　　　21.7.1 映射的构造
　　　21.7.2 映射元素的访问
　　　21.7.3 映射元素的添加
　　　21.7.4 映射元素的删除
　　　21.7.5 映射元素的查找
　　　21.7.6 多重映射
　　21.8 集合
　　　21.8.1 集合的构造
　　　21.8.2 集合元素的访问
　　　21.8.3 集合元素的添加
　　　21.8.4 集合元素的删除
　　　21.8.5 集合元素的查找
　　　21.8.6 多重集合
　　21.9 位集合
　　　21.9.1 位集合的概念
　　　21.9.2 位集合的构造
　　　21.9.3 位集合的输出
　　　21.9.4 位元素的操作
　　　21.9.5 位集合的赋值与转换
　　　21.9.6 位集合的尺寸
　　　21.9.7 位集合的比较
　　　21.9.8 位集合的位操作
　第22章 泛型算法
　　22.1 指示器
　　　22.1.1 指示器的获取
　　　22.1.2 指示器的数据类型
　　　22.1.3 指示器的迭代
　　　22.1.4 迭代的方向*
　　　22.1.5 指示器的迭代类型
　　22.2 指示器适配器
　　　22.2.1 反向指示器
　　　22.2.2 插入型指示器
　　22.3 函数对象
　　22.4 算法
　　　22.4.1 查找算法
　　　22.4.2 排序与通用整序算法
　　　22.4.3 删除和替换算法
　　　22.4.4 排列组合算法
　　　22.4.5 算术算法
　　　22.4.6 生成和异变算法
　　　22.4.7 关系算法
　　　22.4.8 集合算法
　　　22.4.9 堆算法
　第23章 C++实践指南
　　23.1 提高代码的可读性
　　　23.1.1 不要吝啬注释
　　　23.1.2 不要吝啬空白
　　　23.1.3 爱惜标识符
　　　23.1.4 合理使用操作符函数
　　　23.1.5 合理使用别名
　　　23.1.6 合理使用跳转语句
　　23.2 编写笨的程序
　　　23.2.1 书写正常的表达式
　　　23.2.2 使用bool类型进行判断
　　　23.2.3 保证对象的初始化
　　　23.2.4 尽量多写一些if
　　　23.2.5 不要再发明string类
　　　23.2.6 使用标准C++
　　23.3 合理使用内存
　　　23.3.1 C++中的内存
　　　23.3.2 内存的非法访问
　　　23.3.3 内存泄漏
　　　23.3.4 内存泄漏的检测
　　　23.3.5 CMemory State
　　　23.3.6 智能指针（auto_ptr）
　　23.4 合理使用OOP
　　　23.4.1 合理封装对象
　　　23.4.2 对象拷贝的产生
　　　23.4.3 对象的初始化
　　　23.4.4 对象的赋值与初始化
　　　23.4.5 合理使用继承与组合
　　　23.4.6 合理使用多继承
　　　23.4.7　合理使用虚函数和虚基类
　　23.5 不要教条主义
　第24章 综合实践：《西游记》游戏模拟
　　24.1 功能分析
　　　24.1.1 游戏运行界面
　　　24.1.2 游戏角色划分
　　　24.1.3 战斗的形成
　　　24.1.4 兵器的分配
　　24.2 设计思路
　　　24.2.1 使用类和继承完成角色的设计
　　　24.2.2 使用文件流加载角色列表
　　　24.2.3 使用虚函数实现角色的多态
　　　24.2.4 使用操作符的重载
　　　24.2.5 使用异常处理提高程序的鲁棒性
　　　24.2.6 使用RTTI获取角色的类别
　　　24.2.7 使用STL容器管理角色
　　　24.2.8 使用STL容器管理兵器
　　　24.2.9 使用泛型算法完成查找与排序
　　　24.2.10 使用循环和判断完成主控逻辑
　　24.3 实现详解
　　　24.3.1 Weapon
　　　24.3.2 Actor
　　　24.3.3 Monk
　　　24.3.4 ActorPowersAccumulater
　　　24.3.5 God
　　　24.3.6 Monster
　　　24.3.7 FollowerMonster
　　　24.3.8 GameException
　　　24.3.9 Game
　　　24.3.10 main()函数
　　24.4 运行并观察游戏
　　　24.4.1 actors.ini
　　　24.4.2 运行程序