C++面向对象程序设计

第1章  C++编程基础                  
 1. 1  程序语言的发展                  
 1. 1. 1  机器语言                  
 1. 1. 2  汇编语言                  
 1. 1. 3  高级语言                  
 1. 1. 4  C语言                  
 1. 1. 5  C++语言                  
 1. 2  C++语言简介                  
 1. 2. 1  程序＝数据+操作                  
 1. 2. 2  数据类型                  
 1. 2. 3  对数据的操作--表达式                  
 1. 2. 4  数据操作的流程--语句控制                  
 1. 2. 5  操作的复用--函数                  
 1. 2. 6  数据和操作的封装--类                  
 1. 2. 7  类的复用--派生和继承                  
 1. 2. 8  软件模块                  
 1. 3  如何学习C++语言                  
 1. 3. 1  勤能生巧                  
 1. 3. 2  风格与规范                  
 1. 4  用Visual C++开发程序                  
 1. 4. 1  程序--从概念到运行                  
 1. 4. 2  Visual C++简介                  
 1. 4. 3  建立应用程序                  
 1. 5  程序风格                  
 1. 5. 1  效率与风格                  
 1. 5. 2  注释--整理编程思路. 增加程序的可读性                  
 1. 5. 3  注释的形式                  
 1. 5. 4  命名                  
 1. 5. 5  编排                  
 1. 5. 6  简单性原则                  
 1. 5. 7  一致性原则                  
 小结                  
 第2章  基本C++程序结构                  
 2. 1  C++语言成分                  
 2. 1. 1  字符                  
 2. 1. 2  数字. 标识符和表达式                  
 2. 1. 3  语法                  
 2. 1. 4  结构                  
 2. 1. 5  模块                  
 2. 2  程序的基本结构                  
 2. 2. 1  注释                  
 2. 2. 2  编译预处理命令#include                  
 2. 2. 3  main函数                  
 2. 2. 4  C++程序的执行过程                  
 2. 2. 5  终端输出                  
 2. 3  变量和简单表达式                  
 2. 3. 1  main函数的返回值                  
 2. 3. 2  常数和常量                  
 2. 3. 3  变量                  
 2. 3. 4  运算符与简单表达式                  
 2. 4  表达式和语句                  
 2. 4. 1  返回值                  
 2. 4. 2  嵌套                  
 2. 4. 3  优先级                  
 2. 4. 4  结合性                  
 2. 4. 5  括号与次序                  
 2. 4. 6  操作数                  
 小结                  
 习题                  
 第3章  数据类型                  
 3. 1  数据及操作                  
 3. 2  C++数据类型                  
 3. 3  基本数据类型                  
 3. 3. 1  数据在计算机中的存储                  
 3. 3. 2  基本数据类型的修饰符号                  
 3. 3. 3  基本数据类型                  
 3. 3. 4  C++中的特殊字符                  
 3. 3. 5  字符串                  
 3. 3. 6  数据类型长度的确定                  
 3. 3. 7  数据类型的选择                  
 3. 4  构造数据类型                  
 3. 4. 1  数组                  
 3. 4, 2  枚举                  
 3. 4. 3  结构                  
 3. 5  数据输入                  
 小结                  
 第4章  程序流程控制                  
 4. 1  复合语句                  
 4. 2  程序的执行流程                  
 4. 3  分支流程                  
 4. 3. 1  if语句                  
 4. 3. 2  switch语句                  
 4. 4  循环流程                  
 4. 4. 1  while语句                  
 4. 4. 2  do…while语句                  
 4. 4. 3  for循环                  
 4. 5  设计举例                  
 4. 6  其他控制语句                  
 4. 6. 1  break语句与多重循环                  
 4. 6. 2  goto语句                  
 4. 6. 3  条件运算符?：                  
 小结                  
 第5章  函数                  
 5. 1  函数机制                  
 5. 2  函数定义                  
 5. 2. 1  函数名                  
 5. 2. 2  函数参数                  
 5. 2. 3  返回类型                  
 5. 2. 4  函数体                  
 5. 3  函数调用                  
 5. 4  程序运行时的内存分布                  
 5. 5  函数调用的实现机制                  
 5. 6  函数的参数与返回值                  
 5. 7  函数参数的传递方式                  
 5. 7. 1  指针参数                  
 5. 7. 2  引用参数                  
 5. 7. 3  数组参数                  
 5. 7. 4  数组参数对实在参数的改变                  
 5. 7. 5  字符串作为参数                  
 5. 7. 6  多维数组作为参数                  
 5. 7. 7  main()的参数                  
 5. 8  函数返回值                  
 5. 8. 1  返回引用值                  
 5. 9  const参数. const返回值与const函数                  
 5. 9. 1  const参数                  
 5. 9. 2  const返回值                  
 5. 9. 3  const函数                  
 5. 10  作用域                  
 5. 10. 1  局部作用域                  
 5. 10. 2  文件作用域                  
 5. 10. 3  覆盖问题                  
 5. 11  函数原型                  
 5. 11. 1  函数作用域                  
 5. 11. 2  函数原型                  
 5. 11. 3  函数原型的作用                  
 5. 11. 4  使用自己定义的函数原型                  
 5. 12  特殊的函数用法                  
 5. 12. 1  内联函数                  
 5. 12. 2  内联函数的作用                  
 5. 12. 3  内联函数使用的限制                  
 5. 12. 4  函数重载                  
 5. 12. 5  使用函数重载的条件                  
 5. 12. 6  重载函数的使用方法                  
 5. 12. 7  函数的默认参数                  
 5. 12. 8  递归函数                  
 5. 12. 9  设计递归程序的方法                  
 5. 12. 10  递归程序的优缺点                  
 5. 12. 11  函数模板                  
 5. 12. 12  模板的实例化                  
 5. 12. 13  支持多种类型的模板                  
 5. 12. 14  使用模板的注意事项                  
 小结                  
 第6章  简单程序设计                  
 6. 1  程序开发过程                  
 6. 2  文件之间的信息共享                  
 6. 2. 1  外部变量                  
 6. 2. 2  外部函数                  
 6. 2. 3  静态全局变量与静态函数                  
 6. 3  头文件                  
 6. 3. 1  #include指令                  
 6. 3. 2  头文件内容                  
 6. 3. 3  预编译指令                  
 6. 4  生存期                  
 6. 4. 1  生存期与内存                  
 6. 4. 2  初始化问题                  
 6. 4, 3  局部静态变量                  
 小结                  
 第7章  数组与结构                  
 7. 1  数组                  
 7. 1. 1  数组的定义                  
 7. 1. 2  数组元素的访问                  
 7. 1. 3  数组复制                  
 7. 1. 4  数组下标越界                  
 7. 1. 5  数组元素的初始化                  
 7. 1. 6  多维数组                  
 7. 1. 7  多维数组元素的访问                  
 7. 1. 8  多维数组元素的初始化                  
 7. 1. 9  字符串数组                  
 7. 1. 10  数组应用举例                  
 7. 2  结构                  
 7. 2. 1  结构类型的定义                  
 7. 2. 2  结构成员的访问                  
 7. 2. 3  结构变量的初始化                  
 7. 2. 4  结构的赋值                  
 7. 2. 5  结构成员