C++程序员手册

第一部分  C++编译器                  
 第1章  C++编译器概述                  
 1. 1  所遵循的标准                  
 1. 2  C++ Readme文件                  
 1. 3  手册页                  
 1. 4  许可                  
 1. 5  C++编译器的新特性                  
 1. 6  C++工具                  
 1. 7  本地语言的支持                  
 第2章  使用C++编译器                  
 2. 1  开始使用                  
 2. 2  运行编译器                  
 2. 2. 1  命令语法                  
 2. 2. 2  文件命名惯例                  
 2. 2. 3  使用多个源文件                  
 2. 3  用不同版本的编译器编译                  
 2. 4  编译和连接                  
 2. 4. 1  编译连接NJ顺序                  
 2. 4. 2  单独的编译和连接                  
 2. 4. 3  一致编译和连接                  
 2. 4. 4  SPARC V9的编译                  
 2. 4. 5  诊断编译器                  
 2. 4. 6  理解编译器的组织                  
 2. 5  预处理指令和名称                  
 2. 5. 1  Pragmas                  
 2. 5. 2  #define所列的可变参数                  
 2. 5. 3  预定义的名字                  
 2. 5. 4  并error                  
 2. 6  内存需求                  
 2. 6. 1  交换区的大小                  
 2. 6. 2  增大交换区                  
 2. 6. 3  控制虚拟内存                  
 2. 6. 4  内存的需求                  
 2. 7  简化命令                  
 2. 7. 1  在C shell中使用别名                  
 2. 7. 2  使用CCFLAGS来指定编译选项                  
 2. 7. 3  使用make                  
 第3章  使用C++的编译器选项                  
 3. 1  语法                  
 3. 2  通用的法则                  
 3. 3  按功能概述选项                  
 3. 3. 1  代码生成选项                  
 3. 3. 2  调试选项                  
 3. 3. 3  浮点选项                  
 3. 3. 4  语言选项                  
 3. 3. 5  库选项                  
 3. 3. 6  许可选项                  
 3. 3. 7  过时的选项                  
 3. 3. 8  输出选项                  
 3. 3. 9  性能选项                  
 3. 3. 10  预处理器选项                  
 3. 3. 11  配置选项                  
 3. 3. 12  参考选项                  
 3. 3. 13  源选项                  
 3. 3. 14  模板选项                  
 3. 3. 15  线程选项                  
 第二部分  编写C++程序                  
 第4章  语言扩展                  
 4. 1  重载更少限定性的虚函数                  
 4. 2  enum类型和变量的前置声明'                  
 4. 3  使用不完整的enum类型                  
 4. 4  将enum名作为范围限定词                  
 4. 5  使用匿名sbuct体声明                  
 4. 6  传递匿名类实例的地址                  
 4. 7  声明静态的命名空间函数作为类                  
 的友元                  
 4. 8  为函数名使用预定义_func_符号                  
 第5章  程序组织                  
 5. 1  头文件                  
 5. 1. 1  语言适应性头文件                  
 5. 1. 2  幂等头文件                  
 5. 2  模板定义                  
 5. 2. 1  包含式模板定义                  
 5. 2. 2  分离式模板定义                  
 第6章  创建和使用模板                  
 6. 1  函数模板                  
 6. 1. 1  函数模板声明                  
 6. 1. 2  函数模板定义                  
 6. 1. 3  使用函数模板                  
 6. 2  类模板                  
 6. 2. 1  类模板声明                  
 6. 2. 2  类模板定义                  
 6. 2. 3  类模板成员定义                  
 6. 2. 4  使用类模板                  
 6. 3  模板实例化                  
 6. 3. 1  隐式模板实例化                  
 6. 3. 2  类整体实例化                  
 6. 3. 3  显式模板实例化                  
 6. 4  模板合成                  
 6. 5  默认模板参数                  
 6. 6  模板特殊化                  
 6. 6. 1  模板特殊化声明                  
 6. 6. 2  模板特殊化定义                  
 6. 6. 3  模板特殊化的使用和实例化                  
 6. 6. 4  部分特殊化                  
 6. 7  模板使用中的问题                  
 6. 7. 1  非本地命名解析和实例化                  
 6. 7. 2  本地类型作为模板参数                  
 6. 7. 3  模板函数的友元声明                  
 6. 7. 4  在模板定义中使用限定名                  
 6. 7. 5  嵌套模板声明                  
 6. 7. 6  引用静态变量和静态函数                  
 6. 7. 7  在同一目录中建立多个使用                  
 模板的程序                  
 第7章  编译模板                  
 7. 1  verbose编译                  
 7. 2  模板命令                  
 7. 3  模板实例的放置和连接                  
 7. 3. 1  外部实例                  
 7. 3. 2  静态实例                  
 7. 3. 3  全局实例                  
 7. 3. 4  显式实例                  
 7. 3. 5  半显式实例                  
 7. 4  模板库                  
 7. 4. 1  库结构                  
 7. 4. 2  写入模板库                  
 7. 4. 3  读取多个模板库                  
 7. 4. 4  共享模板库                  
 7. 5  模板定义搜索                  
 7. 5. 1  源文件定位规则                  
 7. 5. 2  定义搜索路径                  
 7. 6  模板实例的自动一致性                  
 7. 7  编译时间实例化                  
 7. 8  模板选项文件                  
 7. 8. 1  注释                  
 7. 8. 2  文件包含                  
 7. 8. 3  源文件扩展名                  
 7. 8. 4  定义源位置                  
 7. 8. 5  模板特殊化入口                  
 第8章  异常处理                  
 8. 1  同步和异步异常                  
 8. 2  指定运行时错误                  
 8. 3  禁止异常                  
 8. 4  使用运行时函数和预定义的异常                  
 8. 5  带有信号和Setjmp/Longjmp的                  
 混合异常                  
 8. 6  建立带有异常的共享库                  
 第9章  Cast操作符                  
 9. 1  Const cast                  
 9. 2  reinterpret_cast                  
 9. 3  Static cast                  
 9. 4  dynamic_cast                  
 9. 4. 1  继承层次的向上类型转换                  
 9. 4. 2  转换为void*                  
 9. 4. 3  继承层次的向下和水平类型转换                  
 第lo章  增强程序性能                  
 10. 1  避免临时对象                  
 10. 2  使用内联函数                  
 10. 3  使用默认操作                  
 10. 4  使用数值类                  
 10. 4. 1  选择直接传递类                  
 10. 4. 2  在各种处理器上直接传递类                  
 10. 5  缓存成员变量                  
 第ll章  多线程程序                  
 11. 1  建立多线程程序                  
 11. 1. 1  隐式的多线程编译                  
 11. 1. 2  使用C++支持的线程和信号库                  
 11. 2  在多线程程序中使用异常                  
 11. 3  在线程间共享C++标准库对象                  
 11. 4  在多线程环境中使用经典的iostream                  
 11. 4. 1  MT-Safe iostream库的组织                  
 11. 4. 2  iostream库的接口变化                  
 11. 4. 3  全局和静态数据                  
 11. 4. 4  顺序执行                  
 11. 4. 5  对象锁定                  
 11. 4. 6  MT-Safe类                  
 11. 4. 7  对象析构                  
 11. 4. 8  一个应用程序实例                  
 第三部分库                  
 第12章  使用库                  
 12. 1  C库                  
 12. 2  C++编译器提供的库                  
 12. 2. 1  C++库的描述                  
 12. 2. 2  访问C++库的手册页                  
 12. 2. 3  默认的C++库                  
 12. 3  相关的库选项                  
 12. 4  使用类库                  
 12. 4. 1  iostream库                  
 12. 4. 2  复数库                  
 12. 4. 3  连接C++库                  
 12. 5  静态连接标准库                  
 12. 6  使用共享库                  
 12. 7  替换C++标准库                  
 12. 7. 1  哪些可以被替换                  
 12. 7. 2  哪些不能被替换                  
 12. 7. 3  安装替换的库                  
 12. 7. 4  使用替换的库                  
 12. 7. 5  标准头文件的头现                  
 第13章  使用C++的标准库                  
 13. 1  C++标准库头文件                  
 13. 2  C++标准库手册页                  
 13. 3  STLport                  
 第14章  使用经典的iostream库                  
 14. 1  共享libiostream                  
 14. 2  预定义的iostream                  
 14. 3  iostream交互的基本结构                  
 14. 4  使用经典的iostream库                  
 14. 4. 1  使用iostream输出                  
 14. 4. 2  使用iostream输入                  
 14. 4. 3  定义自己的提取操作符                  
 14. 4. 4  使用char*的提取符                  
 14. 4. 5  读任意的单独字符                  
 14. 4. 6  二进制输入                  
 14. 4. 7  查看输入字符                  
 14. 4. 8  提取空白字符                  
 14. 4. 9  处理输入错误                  
 14. 4. 10  使用iostream和stdio                  
 14. 5  创建iostream                  
 14. 6  iostream的赋值                  
 14. 7  格式控制                  
 14. 8  操纵符                  
 14. 8. 1  使用无格式的操纵符                  
 14. 8. 2  带参数的操纵符                  
 14. 9  数组的strstreams:iostream                  
 14. 10  stdio文件的stdiobufs：iostream                  
 14. 11  streambuf                  
 14. 11. 1  处理streambuf                  
 14. 11. 2  使用streambuf                  
 14. 12  iostream手册页                  
 14. 13  iostream的术语                  
 第15章  使用复数库                  
 15. 1  复数库                  
 15. 2  复数类型                  
 15. 2. 1  complex类的构造函数                  
 15. 2. 2  算术操作符                  
 15. 3  算术函数                  
 15. 4  错误处理                  
 15. 5  输入和输出                  
 15. 6  混合模式的算术                  
 15. 7  效率                  
 15. 8  复数的手册页                  
 第16章  创建库                  
 16. 1  理解库                  
 16. 2  创建静态(文档)库                  
 16. 3  创建动态(共享)库                  
 16. 4  创建包含异常的共享库                  
 16. 5  创建私用的库                  
 16. 6  创建公用的库                  
 16. 7  创建一个有C API的库                  
 16. 8  使用dlopen从C程序访问C++库