C++程序开发与设计

第1章　计算机与程序设计简介　1                  
 1.1　硬件和软件　1                  
 1.1.1  计算机硬件  3                  
 1.1.2  硬件的发展  6                  
 1.1.3  计算机软件                  
 练习1.1  8                  
 1.2　编程语言　10                  
 1.3　问题解决与软件开发　11                  
 1.3.1  阶段一：开发与设计  13                  
 1.3.2  阶段二：编写文档  14                  
 1.3.3  阶段三：维护  15                  
 1.3.4  深入探讨开发与设计  16                  
 1.3.5  备份  16                  
 练习1.3  21                  
 1.4　算法　21                  
 练习1.4  24                  
 1.5　为对象做准备：面向对象的程序设计　25                  
 练习1.5  26                  
 1.6　深入探讨数字式存储的概念　29                  
 1.6.1  二进制补码  29                  
 1.6.2  字与地址  30                  
 1.7　常见编程错误　30                  
 1.8　章节回顾　31                  
 1.8.1  关键术语  31                  
 1.8.2  概要  31                  
 1.8.3  练习  32                  
                   
 第一部分　Ｃ++面向过程的程序设计　35                  
                   
 第２章　用Ｃ++解决问题　37                  
 2.1  C++简介　37                  
 2.1.1  main()函数  39                  
 2.1.2  cout对象  40                  
 练习2.1  42                  
 2.2  程序设计风格　44                  
 练习2.2  46                  
 2.3  数据值与算术运算　47                  
 2.3.1  整数值  47                  
 2.3.2  浮点数  48                  
 2.3.3  字符值  49                  
 2.3.4  转义序列  50                  
 2.3.5  算术运算  51                  
 2.3.6  整数的除法  53                  
 2.3.7  一元运算符  53                  
 2.3.8  运算符的优先级和结合性  54                  
 练习2.3  55                  
 2.4  变量与声明语句　57                  
 2.4.1  声明语句  58                  
 2.4.2  多重声明  60                  
 4.4.3  内存分配  62                  
 4.4.4  显示一个变量的地址  63                  
 练习2.4  65                  
 2.5  整数限定符　67                  
 2.5.1  数据类型转换  68                  
 2.5.2  确定存储长度  68                  
 练习2.5  69                  
 2.6  软件开发过程运用　70                  
 2.6.1  步骤一：分析问题  71                  
 2.6.2  步骤二：研究解决问题  71                  
 2.6.3  步骤三：方案的代码化  71                  
 2.6.4  步骤四：程序的测试与更正  72                  
 练习2.6  72                  
 2.7  注重解决问题　74                  
 2.7.1  问题一：钟摆  74                  
 2.7.2  问题二：直通电话网络  75                  
 练习2.7  76                  
 2.8  为对象做准备：关于“抽象”的简介　77                  
 2.9  常见编程错误　80                  
 2.10  章节回顾　81                  
 2.10.1  关键术语  81                  
 2.10.2  概要  81                  
 2.10.3  练习  82                  
                   
 第3章　基础知识介绍　86                  
 3.1  赋值操作　86                  
 3.1.1  赋值的各种形式  89                  
 3.1.2  累加和  90                  
 3.1.3  计数  91                  
 练习3.1  93                  
 3.2  指定输出数的格式　96                  
 练习3.2  102                  
 3.3  利用数学库函数　104                  
 练习3.3  107                  
 3.4  用cin对象接收程序输入　109                  
 练习3.4  112                  
 3.5  const 限定符　115                  
 练习3.5  117                  
 3.6  注重解决问题　118                  
 3.6.1  问题一：酸雨  118                  
 3.6.2  问题二：指数函数的逼近  120                  
 练习3.6  123                  
 3.7  为对象做准备：程序性能衡量和面向对象技术　125                  
 3.7.1  程序性能的衡量  126                  
 3.7.2  转向面向对象技术  127                  
 练习3.7  128                  
 3.8  深入探讨错误　128                  
 3.8.1  编译时和运行时错误  128                  
 3.8.2  语法和逻辑错误  128                  
 3.9  常见编程错误　131                  
 3.10  章节回顾　131                  
 3.10.1  关键术语  131                  
 3.10.2  概要  132                  
 3.10.3  练习  133                  
                   
 第4章　选择结构　137                  
 4.1 选择条件　137                  
 4.1.1  逻辑运算符  139                  
 4.1.2  数的精度问题  141                  
 练习4.1  142                  
 4.2 if-else语句　143                  
 4.2.1  复合语句  145                  
 4.2.2  代码块的作用范围  147                  
 4.2.3  单选择  147                  
 4.2.4  与if-else语句相关的问题  149                  
 练习4.2  150                  
 4.3 嵌套if语句　152                  
 练习4.3  157                  
 4.4 Switch语句　160                  
 练习4.4  163                  
 4.5 注重解决问题　164                  
 4.5.1  问题一：数据有效性检验  165                  
 4.5.2  问题二：解二次方程  166                  
 练习4.5  169                  
 4.6 为对象做准备：内部和外部　170                  
 4.6.1  抽象与封装  172                  
 4.6.2  代码重用的扩展  172                  
 练习4.6  173                  
 4.7 深入探讨程序测试　174                  
 4.8 常见编程错误　175                  
 4.9 章节回顾　176                  
 4.9.1  关键术语  176                  
 4.9.2  概要  176                  
 4.9.3  练习  178                  
                   
 第5章　循环结构　181                  
 5.1  引言　242                  
 5.1.1   先判断循环与后判断循环  181                  
 5.1.2  固定计数循环与可变条件循环  181                  
 5.2  while 循环　183                  
 练习5.2  188                  
 5.3  交互式while 循环　189                  
 5.3.1  标记  195                  
 5.3.2  break语句与continue语句  196                  
 5.3.3  空语句  197                  
 练习5.3  197                  
 5.4  for循环　199                  
 练习5.4  205                  
 5.5  循环编程技术　208                  
 5.5.1  技术一：在循环中交互输入  208                  
 5.5.2  技术二：在循环中选择  208                  
 5.5.3  技术三：计算单变量函数  210                  
 5.5.4  技术四：交互式循环控制  212                  
 练习5.5  213                  
 5.6  嵌套循环　214                  
 练习5.6  216                  
 5.7  do-while循环　217                  
 练习5.7  219                  
 5.8 为对象做准备：对象建模技术　220                  
 5.8.1  对象图  221                  
 5.8.2  关系  223                  
 练习5.5  224                  
 5.9  常见编程错误　225                  
 5.10  章节回顾　225                  
 5.10.1  关键术语  225                  
 5.10.2  概要  226                  
 5.10.3  练习  227                  
                   
 第6章　用函数实现模块化　231                  
 6.1 函数声明与参数声明　231                  
 6.1.1  函数原型  232                  
 6.1.2  调用一个函数  233                  
 6.1.3  定义一个函数  234                  
 6.1.4  语句的位置  237                  
 6.1.5  函数占位符  238                  
 6.1.6  带有空参数列表的函数  239                  
 6.1.7  缺省参数  240                  
 6.1.8  函数模板  240                  
 6.1.9  重用函数名(重载)  244                  
 练习6.1  245                  
 6.2 返回值　246                  
 练习6.2  251                  
 6.3 变量的作用范围　253                  
 6.3.1  范围解析运算符  256                  
 6.3.2  全局变量的误用  256                  
 练习6.3  257                  
 6.4 变量存储类型　259                  
 6.4.1  局部变量存储类型  260                  
 6.4.2  全局变量存储类型  263                  
 练习6.4  264                  
 6.5 使用引用参数的引用传递　265                  
 练习6.5  272                  
 6.6 递归　273                  
 6.6.1  数学递归  273                  
 6.6.2  计算是如何执行的  275                  
 6.6.3  递归和迭代  276                  
 练习6.6  277                  
 6.7 注重解决问题　277                  
 6.7.1  产生伪随机数  277                  
 6.7.2  问题一：模拟抛硬币  279                  
 6.7.3  问题二：编写一个HiLo游戏  281                  
 6.7.4  问题三：用蒙特卡洛模拟估计曲线下的面积  283                  
 练习6.7  287                  
 6.8 为对象做准备：动态OMT模型　290                  
 6.8.1  动态模型  290                  
 6.8.2  一个例子  292                  
 练习6.8  293                  
 6.9 常见编程错误　294                  
 6.10 章节回顾　294                  
 6.10.1  关键术语  294                  
 6.10.2  概要  294                  
 6.10.3  练习  295                  
                   
 第二部分　C++面向对象的程序设计　303                  
                   
 第7章　类的介绍　305                  
 7.1  C++中的抽象数据类型(类)　305                  
 7.1.1  抽象数据类型  305                  
 7.1.2  类的构造  307                  
 7.1.3  术语  313                  
 练习7.1  313                  
 7.2  构造函数　315                  
 7.2.1  构造函数和调用  316                  
 7.2.2  重载和内联构造函数  317                  
 7.2.3  析构函数  320                  
 练习7.2  321                  
 7.3   注重解决问题　321                  
 7.3.1  问题一：构造一个电梯对象  322                  
 7.3.2  问题二：汽油泵对象的仿真  326                  
 练习7.3  331                  
 7.4  常见编程错误　332                  
 7.5  章节回顾　332                  
 7.5.1  关键术语  332                  
 7.5.2  概要  332                  
 7.5.3  练习  333                  
                   
 第8章　类的函数和转换　335                  
 8.1  赋值　335                  
 8.1.1  复制构造函数  338                  
 8.1.2  基础/成员初始化  340                  
 练习8.1  341                  
 8.2  类的其他特征　341                  
 8.2.1  类的作用范围  341                  
 8.2.2  静态类成员  343                  
 8.2.3  友元函数  346                  
 练习8.2  348                  
 8.3  运算符函数　349                  
 练习8.3  355                  
 8.4  用户的两种选择：operator()和operator[]　356                  
 练习8.4  359                  
 8.5  数据类型转换　359                  
 8.5.1  内置数据类型转换成内置数据类型  360                  
 8.5.2  内置数据类型转换成类  360                  
 8.5.3  类转换成内置数据类型  362                  
 8.5.4  类转换成类型 363                  
 练习8.5  366                  
 8.6  注重解决问题　367                  
 8.6.1  问题一：多个对象的汽油泵仿真  367                  
 8.6.2  问题二：重载插入(  )和提取(  )运算符  372                  
 练习8.6  375                  
 8.7  常见编程错误　376                  
 8.8  章节回顾　377                  
 8.8.1  关键术语  377                  
 8.8.2  概要  377                  
 8.8.3  练习  378                  
                   
 第9章　继承和动态内存分配　381                  
 9.1  类的继承　381                  
 9.1.1  访问标志  383                  
 9.1.2  一个例子  283                  
 练习9.1  387                  
 9.2  多态性　387                  
 练习9.2  390                  
 9.3  this指针　391                  
 练习9.3  396                  
 9.4  注重解决问题　396                  
 9.4.1  问题一：对象的动态生成与销毁  396                  
 9.4.2  问题二：汽油泵的动态仿真  401                  
 练习9.4  405                  
 9.5  作为类成员的指针　406                  
 练习9.5  412                  
 9.6  常见编程错误　412                  
 9.7 章节回顾　413                  
 9.7.1  关键术语  413                  
 9.7.2  概要  413                  
 9.7.3  练习  413                  
                   
 第10章　I/O文件流和数据文件　415                  
 10.1  I/0文件流对象和方法　415                  
 10.1.1  文件  415                  
 10.1.2  文件流对象和模式  416                  
 10.1.3  文件流的方法  417                  
 10.1.4  嵌入程序和交互输入的文件名  421                  
 10.1.5  关闭文件  423                  
 练习10.1  423                  
 10.2  读文件和写文件　424                  
 10.2.1  标准设备文件  429                  
 10.2.2  其他设备  429                  
 练习10.2  430                  
 10.3  文件的随机访问　431                  
 练习10.3  434                  
 10.4  将文件流作为函数的输入参数　434                  
 练习10.4  437                  
 10.5  注重解决问题　437                  
 10.5.1  问题一：花粉统计的单文件更新  437                  
 10.5.2  问题二：主文件/事务文件更新  442                  
 练习10.5  4446                  
 10.6  深入探讨iostream类库　448                  
 10.6.1  文件流传输机制  448                  
 10.6.2  iostream类库的组件  448                  
 10.6.3  iostream在内存中的格式  449                  
 10.7  常见编程错误　451                  
 10.8  章节回顾　451                  
 10.8.1  关键术语  451                  
 10.8.2  概要  451                  
 10.8.3  练习  453                  
                   
 第三部分　数据结构　455                  
                   
 第11章　数组　457                  
 11.1 一维数组　587                  
 11.2 数组的初始化　596                  
 11.3 用数组作为函数参数　599                  
 11.4 声明和使用二维数组　604                  
 11.5 注重解决问题　613                  
 11.6 查找和排序　621                  
 11.7 常见编程错误　644                  
 11.8 章节回顾　645                  
 第12章　650                  
 字符串　650                  
 12.1 字符串基础　651                  
 12.2 库函数　663                  
 12.3注重解决问题　673                  
 12.4 深入探讨CString类　680                  
 12.5 常见编程错误　684                  
 第13章　689                  
 地址. 指针和数组　689                  
 13.1 地址和指针　690                  
 13.2 数组名作为指针　701                  
 13.3 指针运算　709                  
 13.4 传递地址　713                  
 13.5 指针和字符串库函数　723                  
 13.6 字符串定义和指针数组　726                  
 13.7常见编程错误　731                  
 13.8 章节回顾　733                  
 第14章　736                  
 作为数据结构的记录　736                  
 14.1 单个记录　737                  
 14.2 结构体数组　743                  
 14.3 记录结构用作函数参数　747                  
 14.4 链表　754                  
 14.5 结构体动态内存分配　761                  
 14.6 注重解决问题　767                  
 14.7联合体 　779                  
 14.8 常见编程错误　781                  
 14.9章节回顾　781                  
 第15章　785                  
 面向对象的堆栈和队列　785                  
 15.1 堆栈介绍　786                  
 15.2 动态链接堆栈的实现　795                  
 15.3 队列介绍　803                  
 15.4 动态链接队列的实现　811                  
 15.5 常见编程错误　820                  
 15.6 章节回顾　820                  
 附录　823                  
 附录A　824                  
 运算符优先顺序表　824                  
 附录B　827                  
 ASCII字符编码　827                  
 附录C　833                  
 程序的输入. 编译和执行　833                  
 附录D　839                  
 输入. 输出和标准错误重定向　839                  
 附录E　842                  
 浮点数的存储　842                  
 附录F　845                  
 名称空间　845                  
 附录G　848                  
 标准模板库　848                  
 附录H　855                  
 使用 Visual C++ 6.0　855                  
 附录I　865                  
 使用C++ BuilderTM　865                  
 附录J　869                  
 附加性能　869                  
 附录K　881                  
 部分奇数编号习题的答案　881