顶部
  1. 首页
  2. 图书产品
  3. 面向对象程序设计基础（第二版）
收藏

面向对象程序设计基础（第二版）

面向21世纪课程教材
样章
作者：
李师贤 李文军 周晓聪 李宏新 林瑛
定价：
35.00 元
版面字数：
670千字
开本：
16开
装帧形式：
平装
版次：
2
最新版次
印刷时间：
2022年
ISBN：
978-7-04-016650-7
物料号：
16650-00
出版时间：
2005-03-18
读者对象：
高等教育
一级分类：
计算机/教育技术类
二级分类：
计算机类专业核心课程
三级分类：
程序设计基础

本书第一版被列入“面向21世纪课程教材&rdquo

  • 目录
    • 前辅文
      • 第一章　程序设计与C++语言初步
        • 1.1　计算机程序
          • 1.1.1　算法
            • 1.1.2　实体
              • 1.1.3　程序
                • 1.1.4　程序设计
                • 1.2　程序设计的演变
                  • 1.2.1　早期程序设计
                    • 1.2.2　结构化程序设计
                      • 1.2.3　面向对象程序设计
                      • 1.3　程序设计语言的定义
                        • 1.3.1　语法和语义
                          • 1.3.2　字符集
                            • 1.3.3　Backus-Naur范式
                              • 1.3.4　语法图
                              • 1.4　C++语言的程序结构
                                • 1.4.1　C++语言程序的组成
                                  • 1.4.2　C++语言程序的基本结构
                                    • 1.4.3　C++语言程序的退化结构
                                    • 1.5　C++语言程序的运行
                                      • 1.6　面向对象程序设计
                                        • 1.6.1　面向对象程序设计过程
                                          • 1.6.2　面向对象程序设计的特征
                                          • 本章小结
                                            • 练习与思考题
                                              • 上机实习题
                                              • 第二章　基本数据类型
                                                • 2.1　数据类型概述
                                                  • 2.1.1　类型
                                                    • 2.1.2　类型的作用
                                                      • 2.1.3　C++语言的类型
                                                      • 2.2　保留字、标识符、常量与变量
                                                        • 2.2.1　单词
                                                          • 2.2.2　保留字
                                                            • 2.2.3　标识符
                                                              • 2.2.4　选择合适的标识符
                                                                • 2.2.5　常量与变量
                                                                  • 2.2.6　简单输入/输出
                                                                  • 2.3　基本数据类型
                                                                    • 2.3.1　字符类型
                                                                      • 2.3.2　整数类型
                                                                        • 2.3.3　浮点类型和双精度类型
                                                                          • 2.3.4　字符串常量
                                                                            • 2.3.5　符号常量
                                                                            • 2.4　运算符与表达式
                                                                              • 2.4.1　表达式
                                                                                • 2.4.2　表达式的运算次序
                                                                                  • 2.4.3　C++的运算符
                                                                                    • 2.4.4　算术运算
                                                                                      • 2.4.5　关系运算
                                                                                        • 2.4.6　逻辑运算
                                                                                          • 2.4.7　位运算
                                                                                            • 2.4.8　条件运算
                                                                                              • 2.4.9　sizeof运算
                                                                                                • 2.4.10　赋值运算
                                                                                                  • 2.4.11　逗号运算
                                                                                                    • 2.4.12　表达式与运算符的应用举例
                                                                                                    • 2.5　类型之间的关系
                                                                                                      • 2.5.1　隐式类型转换
                                                                                                        • 2.5.2　强制类型转换
                                                                                                        • 2.6　一个简单的应用程序
                                                                                                          • 本章小结
                                                                                                            • 练习与思考题
                                                                                                              • 上机实习题
                                                                                                              • 第三章　基本控制结构
                                                                                                                • 3.1　程序的基本控制结构
                                                                                                                  • 3.1.1　C++语言的简单语句
                                                                                                                    • 3.1.2　单入口/单出口控制结构
                                                                                                                      • 3.1.3　结构化程序设计工具
                                                                                                                      • 3.2　选择结构
                                                                                                                        • 3.2.1　if语句
                                                                                                                          • 3.2.2　switch语句
                                                                                                                          • 3.3　循环结构
                                                                                                                            • 3.3.1　while语句
                                                                                                                              • 3.3.2　do_while语句
                                                                                                                                • 3.3.3　for语句
                                                                                                                                  • 3.3.4　一个简单的循环例子
                                                                                                                                    • 3.3.5　设计正确的循环
                                                                                                                                    • 3.4　简单程序设计举例
                                                                                                                                      • 3.4.1　问题
                                                                                                                                        • 3.4.2　求解问题的精美算法
                                                                                                                                          • 3.4.3　求解问题的原始算法
                                                                                                                                          • 本章小结
                                                                                                                                            • 练习与思考题
                                                                                                                                              • 上机实习题
                                                                                                                                              • 第四章　函数
                                                                                                                                                • 4.1　C++语言的函数
                                                                                                                                                  • 4.1.1　例程与函数
                                                                                                                                                    • 4.1.2　函数的建立与使用
                                                                                                                                                      • 4.1.3　两个简单的例子
                                                                                                                                                      • 4.2　函数的声明与调用
                                                                                                                                                        • 4.2.1　函数声明
                                                                                                                                                          • 4.2.2　return语句
                                                                                                                                                            • 4.2.3　函数调用
                                                                                                                                                              • 4.2.4　函数与模块
                                                                                                                                                                • 4.2.5　内联函数
                                                                                                                                                                • 4.3　参数传递
                                                                                                                                                                  • 4.3.1　参数传递方式
                                                                                                                                                                    • 4.3.2　按值调用
                                                                                                                                                                      • 4.3.3　缺省参数
                                                                                                                                                                      • 4.4　作用域与生存期
                                                                                                                                                                        • 4.4.1　标识符的作用域
                                                                                                                                                                          • 4.4.2　C++程序的存储组织
                                                                                                                                                                            • 4.4.3　变量的生存期
                                                                                                                                                                            • 4.5　局部变量与全局变量
                                                                                                                                                                              • 4.5.1　局部变量
                                                                                                                                                                                • 4.5.2　全局变量
                                                                                                                                                                                  • 4.5.3　局部变量与全局变量的讨论
                                                                                                                                                                                  • 4.6　变量的存储类别
                                                                                                                                                                                    • 4.6.1　自动变量和寄存器变量
                                                                                                                                                                                      • 4.6.2　静态变量
                                                                                                                                                                                        • 4.6.3　外部变量
                                                                                                                                                                                        • 4.7　递归程序设计
                                                                                                                                                                                          • 4.7.1　简单递归程序
                                                                                                                                                                                            • 4.7.2　梵塔问题
                                                                                                                                                                                            • 4.8　预处理命令
                                                                                                                                                                                              • 4.8.1　文件包含
                                                                                                                                                                                                • 4.8.2　宏定义
                                                                                                                                                                                                  • 4.8.3　条件编译
                                                                                                                                                                                                  • 4.9　C++语言的库函数
                                                                                                                                                                                                    • 4.9.1　库函数的用法
                                                                                                                                                                                                      • 4.9.2　常用数值函数
                                                                                                                                                                                                        • 4.9.3　常用字符函数
                                                                                                                                                                                                        • 本章小结
                                                                                                                                                                                                          • 练习与思考题
                                                                                                                                                                                                            • 上机实习题
                                                                                                                                                                                                            • 第五章　类与对象
                                                                                                                                                                                                              • 5.1　类的引入
                                                                                                                                                                                                                • 5.1.1　循环计数器
                                                                                                                                                                                                                  • 5.1.2　关于循环计数器的讨论
                                                                                                                                                                                                                    • 5.1.3　类作为构造程序的基本单位
                                                                                                                                                                                                                    • 5.2　类的定义
                                                                                                                                                                                                                      • 5.2.1　类声明
                                                                                                                                                                                                                        • 5.2.2　类成员的访问控制
                                                                                                                                                                                                                          • 5.2.3　类界面与类实现
                                                                                                                                                                                                                            • 5.2.4　标识符的类作用域
                                                                                                                                                                                                                            • 5.3　对象的创建
                                                                                                                                                                                                                              • 5.3.1　对象声明
                                                                                                                                                                                                                                • 5.3.2　使用对象成员
                                                                                                                                                                                                                                  • 5.3.3　对象的生存期
                                                                                                                                                                                                                                  • 5.4　对象的初始化
                                                                                                                                                                                                                                    • 5.4.1　构造函数
                                                                                                                                                                                                                                      • 5.4.2　析构函数
                                                                                                                                                                                                                                        • 5.4.3　对象成员的初始化
                                                                                                                                                                                                                                        • 5.5　使用类与对象构造程序的实例
                                                                                                                                                                                                                                          • 5.5.1　模拟数字式时钟
                                                                                                                                                                                                                                            • 5.5.2　模拟加油站油泵的对象工作
                                                                                                                                                                                                                                              • 5.5.3　单实例对象类
                                                                                                                                                                                                                                              • 5.6　关于类与对象的进一步讨论
                                                                                                                                                                                                                                                • 5.6.1　基本数据类型与对象
                                                                                                                                                                                                                                                  • 5.6.2　抽象数据类型
                                                                                                                                                                                                                                                    • 5.6.3　设计良好的类界面
                                                                                                                                                                                                                                                      • 5.6.4　再论对象
                                                                                                                                                                                                                                                        • 5.6.5　下一步
                                                                                                                                                                                                                                                        • 本章小结
                                                                                                                                                                                                                                                          • 练习与思考题
                                                                                                                                                                                                                                                            • 上机实习题
                                                                                                                                                                                                                                                            • 第六章　复合数据类型
                                                                                                                                                                                                                                                              • 6.1　变量与赋值的进一步讨论
                                                                                                                                                                                                                                                                • 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.3.4　一维数组应用举例
                                                                                                                                                                                                                                                                                  • 6.3.5　二维数组的声明
                                                                                                                                                                                                                                                                                    • 6.3.6　二维数组元素的引用与初始化
                                                                                                                                                                                                                                                                                      • 6.3.7　二维数组应用举例
                                                                                                                                                                                                                                                                                        • 6.3.8　指针与数组
                                                                                                                                                                                                                                                                                          • 6.3.9　指针数组与数组指针
                                                                                                                                                                                                                                                                                          • 6.4　字符串
                                                                                                                                                                                                                                                                                            • 6.4.1　字符串常量与变量
                                                                                                                                                                                                                                                                                              • 6.4.2　字符串数组
                                                                                                                                                                                                                                                                                                • 6.4.3　关于字符串操作的库函数
                                                                                                                                                                                                                                                                                                  • 6.4.4　字符串与指针数组应用的例子（主函数带参数）
                                                                                                                                                                                                                                                                                                  • 6.5　指向对象的指针
                                                                                                                                                                                                                                                                                                    • 6.5.1　对象指针
                                                                                                                                                                                                                                                                                                      • 6.5.2　对象的动态创建与撤销
                                                                                                                                                                                                                                                                                                        • 6.5.3　对象的复制与比较
                                                                                                                                                                                                                                                                                                        • 6.6　指向函数的指针
                                                                                                                                                                                                                                                                                                          • 6.6.1　函数指针
                                                                                                                                                                                                                                                                                                            • 6.6.2　函数指针作为参数
                                                                                                                                                                                                                                                                                                              • 6.6.3　主动对象
                                                                                                                                                                                                                                                                                                              • 6.7　结构类型、枚举类型与类型别名
                                                                                                                                                                                                                                                                                                                • 6.7.1　结构类型
                                                                                                                                                                                                                                                                                                                  • 6.7.2　枚举类型
                                                                                                                                                                                                                                                                                                                    • 6.7.3　类型别名
                                                                                                                                                                                                                                                                                                                    • 6.8　高级数据结构应用
                                                                                                                                                                                                                                                                                                                      • 本章小结
                                                                                                                                                                                                                                                                                                                        • 练习与思考题
                                                                                                                                                                                                                                                                                                                          • 上机实习题
                                                                                                                                                                                                                                                                                                                          • 第七章　继承机制
                                                                                                                                                                                                                                                                                                                            • 7.1　继承的基本概念
                                                                                                                                                                                                                                                                                                                              • 7.1.1　IS-A关系
                                                                                                                                                                                                                                                                                                                                • 7.1.2　继承机制
                                                                                                                                                                                                                                                                                                                                  • 7.1.3　继承的作用
                                                                                                                                                                                                                                                                                                                                    • 7.1.4　继承与软件重用
                                                                                                                                                                                                                                                                                                                                      • 7.1.5　C++继承常见的几种形式
                                                                                                                                                                                                                                                                                                                                      • 7.2　C++语言的继承机制
                                                                                                                                                                                                                                                                                                                                        • 7.2.1　继承的语法
                                                                                                                                                                                                                                                                                                                                          • 7.2.2　继承成员的访问控制规则
                                                                                                                                                                                                                                                                                                                                            • 7.2.3　一个应用继承机制的完整例子
                                                                                                                                                                                                                                                                                                                                              • 7.2.4　派生类对象的存储组织
                                                                                                                                                                                                                                                                                                                                                • 7.2.5　类型兼容性
                                                                                                                                                                                                                                                                                                                                                • 7.3　继承与构造函数、析构函数
                                                                                                                                                                                                                                                                                                                                                  • 7.3.1　构造函数与析构函数的调用次序
                                                                                                                                                                                                                                                                                                                                                    • 7.3.2　向基类构造函数传递实际参数
                                                                                                                                                                                                                                                                                                                                                    • 7.4　继承成员的调整
                                                                                                                                                                                                                                                                                                                                                      • 7.4.1　恢复访问控制方式
                                                                                                                                                                                                                                                                                                                                                        • 7.4.2　继承成员的重定义
                                                                                                                                                                                                                                                                                                                                                          • 7.4.3　继承成员的重命名
                                                                                                                                                                                                                                                                                                                                                            • 7.4.4　屏蔽继承成员
                                                                                                                                                                                                                                                                                                                                                            • 7.5　多重继承
                                                                                                                                                                                                                                                                                                                                                              • 7.5.1　多重继承的应用背景
                                                                                                                                                                                                                                                                                                                                                                • 7.5.2　多重继承的语法形式
                                                                                                                                                                                                                                                                                                                                                                  • 7.5.3　多重继承的名字冲突问题
                                                                                                                                                                                                                                                                                                                                                                    • 7.5.4　多重继承的构造函数和析构函数
                                                                                                                                                                                                                                                                                                                                                                    • 7.6　重复继承
                                                                                                                                                                                                                                                                                                                                                                      • 7.6.1　重复继承的应用背景
                                                                                                                                                                                                                                                                                                                                                                        • 7.6.2　重复继承的二义性问题
                                                                                                                                                                                                                                                                                                                                                                          • 7.6.3　虚基类
                                                                                                                                                                                                                                                                                                                                                                            • 7.6.4　虚基类的构造函数和析构函数
                                                                                                                                                                                                                                                                                                                                                                            • 7.7　优化类层次设计
                                                                                                                                                                                                                                                                                                                                                                              • 7.7.1　抽象与具体
                                                                                                                                                                                                                                                                                                                                                                                • 7.7.2　封装与开放
                                                                                                                                                                                                                                                                                                                                                                                  • 7.7.3　使用继承与使用对象成员
                                                                                                                                                                                                                                                                                                                                                                                    • 7.7.4　典型类层次
                                                                                                                                                                                                                                                                                                                                                                                      • 7.7.5　其他技术
                                                                                                                                                                                                                                                                                                                                                                                      • 本章小结
                                                                                                                                                                                                                                                                                                                                                                                        • 练习与思考题
                                                                                                                                                                                                                                                                                                                                                                                          • 上机实习题
                                                                                                                                                                                                                                                                                                                                                                                          • 第八章　多态性
                                                                                                                                                                                                                                                                                                                                                                                            • 8.1　多态性的基本概念
                                                                                                                                                                                                                                                                                                                                                                                              • 8.1.1　程序的多态性
                                                                                                                                                                                                                                                                                                                                                                                                • 8.1.2　多态性的作用——表示独立性
                                                                                                                                                                                                                                                                                                                                                                                                • 8.2　函数重载
                                                                                                                                                                                                                                                                                                                                                                                                  • 8.2.1　函数重载的方法
                                                                                                                                                                                                                                                                                                                                                                                                    • 8.2.2　函数重载的注意事项
                                                                                                                                                                                                                                                                                                                                                                                                      • 8.2.3　函数重载的二义性
                                                                                                                                                                                                                                                                                                                                                                                                        • 8.2.4　构造函数重载
                                                                                                                                                                                                                                                                                                                                                                                                        • 8.3　拷贝构造函数
                                                                                                                                                                                                                                                                                                                                                                                                          • 8.3.1　函数按值调用传递对象参数产生的问题
                                                                                                                                                                                                                                                                                                                                                                                                            • 8.3.2　对象作为函数返回值产生的问题
                                                                                                                                                                                                                                                                                                                                                                                                              • 8.3.3　问题的解决——拷贝构造函数
                                                                                                                                                                                                                                                                                                                                                                                                              • 8.4　运算符重载
                                                                                                                                                                                                                                                                                                                                                                                                                • 8.4.1　运算符函数
                                                                                                                                                                                                                                                                                                                                                                                                                  • 8.4.2　类成员运算符重载
                                                                                                                                                                                                                                                                                                                                                                                                                    • 8.4.3　重载一元运算符“-”
                                                                                                                                                                                                                                                                                                                                                                                                                      • 8.4.4　重载赋值运算符“=”
                                                                                                                                                                                                                                                                                                                                                                                                                        • 8.4.5　重载下标运算符“［ ］”
                                                                                                                                                                                                                                                                                                                                                                                                                          • 8.4.6　友元
                                                                                                                                                                                                                                                                                                                                                                                                                            • 8.4.7　友元运算符重载
                                                                                                                                                                                                                                                                                                                                                                                                                              • 8.4.8　运算符重载的其他规则
                                                                                                                                                                                                                                                                                                                                                                                                                              • 8.5　虚函数
                                                                                                                                                                                                                                                                                                                                                                                                                                • 8.5.1　什么是虚函数
                                                                                                                                                                                                                                                                                                                                                                                                                                  • 8.5.2　静态绑定与动态绑定
                                                                                                                                                                                                                                                                                                                                                                                                                                    • 8.5.3　设计合适的绑定方式
                                                                                                                                                                                                                                                                                                                                                                                                                                    • 8.6　抽象类
                                                                                                                                                                                                                                                                                                                                                                                                                                      • 8.6.1　纯虚函数
                                                                                                                                                                                                                                                                                                                                                                                                                                        • 8.6.2　抽象类
                                                                                                                                                                                                                                                                                                                                                                                                                                          • 8.6.3　纯虚函数与抽象类的应用——多态数据结构
                                                                                                                                                                                                                                                                                                                                                                                                                                          • 本章小结
                                                                                                                                                                                                                                                                                                                                                                                                                                            • 练习与思考题
                                                                                                                                                                                                                                                                                                                                                                                                                                              • 上机实习题
                                                                                                                                                                                                                                                                                                                                                                                                                                              • 第九章　类属机制
                                                                                                                                                                                                                                                                                                                                                                                                                                                • 9.1　类属的基本概念
                                                                                                                                                                                                                                                                                                                                                                                                                                                  • 9.1.1　类型的严格性与灵活性
                                                                                                                                                                                                                                                                                                                                                                                                                                                    • 9.1.2　解决冲突的途径
                                                                                                                                                                                                                                                                                                                                                                                                                                                      • 9.1.3　类属机制
                                                                                                                                                                                                                                                                                                                                                                                                                                                      • 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.3.4　类属函数的重载
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • 本章小结
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • 练习与思考题
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • 上机实习题
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • 第十章　输入/输出流
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • 10.1　C++语言的输入/输出
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • 10.1.1　外部设备与文件
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • 10.1.2　程序中对文件的操作
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • 10.1.3　文件的基本概念
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • 10.2　C++的流类库
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • 10.2.1　流类库的基本结构
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • 10.2.2　预定义的流
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • 10.2.3　支持文件的流类
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • 10.2.4　支持字符串的流类
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • 10.3　格式化输入/输出
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • 10.3.1　使用ios成员函数
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • 10.3.2　使用输入/输出操纵符
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • 10.3.3　格式化输出到字符串
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • 10.4　常用成员函数输入/输出
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • 10.4.1　put成员函数
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • 10.4.2　write成员函数
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • 10.4.3　read和gcount成员函数
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • 10.4.4　get成员函数
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • 10.4.5　getline成员函数
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • 10.4.6　peek、putback和ignore成员函数
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • 10.5　设计自己的输入/输出操作
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • 10.5.1　重载流的插入操作
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • 10.5.2　重载流的提取操作
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • 10.5.3　一个完整的实例
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • 10.5.4　设计自己的输入/输出操纵符
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • 10.6　检测流操作的错误
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • 10.7　文件流
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • 10.7.1　文件的打开与关闭
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • 10.7.2　文本文件的操作
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • 10.7.3　二进制文件的操作
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • 10.7.4　文件的随机读/写
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • 10.7.5　程序的打印输出
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • 本章小结
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • 练习与思考题
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • 上机实习题
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • 第十一章　面向对象软件构造
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • 11.1　软件质量
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • 11.2　程序断言机制
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • 11.2.1　程序断言
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • 11.2.2　程序断言的用法
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • 11.2.3　在C++语言中实现部分断言
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • 11.3　异常处理机制
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • 11.3.1　异常处理
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • 11.3.2　异常处理的模式
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • 11.3.3　C++语言的异常处理机制
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • 11.3.4　捕获所有类型的异常
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • 11.3.5　带有异常说明的函数原型
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • 11.3.6　异常的逐层传递
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • 11.3.7　创建对象时的异常处理
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • 11.4　可重用构件库
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • 11.4.1　可重用构件库开发规范
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • 11.4.2　基本术语定义
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • 11.4.3　构件库组织形式与使用方法
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • 11.4.4　构件库设计风格
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • 11.4.5　构件库设计原则
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • 11.4.6　构件库文档编制指南
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • 11.5　面向对象软件构造
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • 11.5.1　标识对象与行为
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • 11.5.2　标识对象之间的关系
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • 11.5.3　建立对象的类描述
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • 11.5.4　创建并驱动对象的运行
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • 11.6　实例研究：Petri网图形编辑器
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • 11.6.1　问题定义
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • 11.6.2　对象之间关系与类的设计
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • 11.6.3　关于Petri网图形编辑器的讨论
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • 本章小结
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • 练习与思考题
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • 上机实习题
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • 第十二章　结束语
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • 12.1　程序设计风范
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • 12.1.1　过程程序设计
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • 12.1.2　模块程序设计
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • 12.1.3　类型程序设计
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • 12.1.4　面向对象程序设计
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • 12.1.5　其他程序设计风范
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • 12.2　面向对象程序设计语言
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • 12.2.1　Simula语言
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • 12.2.2　Smalltalk语言
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • 12.2.3　C++语言
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • 12.2.4　Eiffel语言
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • 12.2.5　Java语言
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • 本章小结
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • 练习与思考题
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • 上机实习题
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • 附录A　ASCII编码表
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • 附录B　主要术语索引
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • 附录C　主要参考文献

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        相关图书

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        程序设计语言概念（第七版 影印版）

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        [美] Robert W. Sebesta

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        49.00 元 收藏

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        C++程序设计实验教程

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        李师贤等

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        25.70 元 收藏

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        C++程序设计实验教程(换封面)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        李师贤等

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        30.00 元 收藏

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        程序设计语言理论（第二版）

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        陈意云 张昱

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        36.50 元 收藏

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Java程序设计（第2版）

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        刘宝林

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        28.00 元 收藏

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Java面向对象程序设计

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        苏健

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        36.70 元 收藏

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        C++: 面向对象程序设计（第2版）

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        李涛 杨剑波

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        35.00 元 收藏

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        C语言程序设计(第2版)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        苏小红 王宇颖 孙志岗 等编著

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        43.00 元 收藏

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        C语言程序设计(第2版)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        苏小红 王宇颖 孙志岗 等编著

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        43.00 元 收藏

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        程序设计案例教程（C语言版）

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        赵秀岩 于晓强

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        49.80 元 收藏

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        C/C++程序设计案例教程实验与实训指导

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        梅险等

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        25.20 元 收藏

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        C语言程序设计(第3版)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        苏小红 王宇颖 孙志岗 等

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        45.00 元 收藏

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Java编程基础及应用

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        强彦 赵涓涓

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        36.00 元 收藏

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        新标准C++程序设计

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        郭炜

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        29.60 元 收藏

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        C语言程序设计(第4版)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        苏小红 赵玲玲 孙志岗 王宇颖 等

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        49.00 元 收藏