顶部
收藏

程序设计语言C++及开发应用(新封面)

中职精品工程_紧缺人才

作者:
眭碧霞
定价:
20.80 元
版面字数:
400千字
开本:
暂无
装帧形式:
暂无
版次:
暂无
最新版次
印刷时间:
1899年
ISBN:
978-7-04-015167-1
物料号:
15167-A0
出版时间:
2004-07-09
读者对象:
五年制高职
一级分类:
计算机类
二级分类:
计算机应用与软件技术

本书根据教育部《高等职业教育计算机应用和软件技术专业领域技能型紧缺人才培养指导方案》编写。

本书按项目教学法组织教材。全书共11章,第1章引入面向对象方法,第2章介绍创建对象的一般方法,第3章引入运算符并介绍判定结构,第4章介绍函数与类,第5章介绍构造函数和析构函数的功能、声明与应用,第6章介绍指针和引用,第7章介绍类的继承,第8章介绍对象的多态性,第9章介绍流类库与输入输出,第10章介绍函数模板、类模板和C++标准模板库,第11章介绍C++中的异常处理。

本书配有《C++习题与实训》,帮助学习者更好地掌握学习内容。

本书适合作为五年制高等职业院校教材,也可作为各类培训班教材。

  • 目录
    • 第1章 引入面向对象方法
      • 1.1 计算机程序设计语言的发展
        • 1.2 面向对象方法学
          • 1.2.1 软件系统的复杂性
            • 1.2.2 简化系统的复杂性
              • 1.2.3 面向对象开发方法的基础
                • 1.2.4 面向对象开发方法的优点
                • 1.3 分析、设计和实现
                  • 1.3.1 面向对象分析OOA
                    • 1.3.2 面向对象设计OOD
                      • 1.3.3 面向对象实现OOP
                        • 1.3.4 面向对象的程序设计方法与结构化程序设计方法的比较
                        • 1.4 C++创建类
                          • 本章小结
                            • 习题
                            • 第2章 创建对象
                              • 2.1 编写C++程序
                                • 2.1.1 C++程序实例
                                  • 2.1.2 C++标识符
                                    • 2.1.3 C++程序成分
                                      • 2.1.4 程序的编辑、编译、连接和执行
                                      • 2.2 基本数据类型
                                        • 2.2.1 基本数据类型
                                          • 2.2.2 常量
                                            • 2.2.3 变量
                                            • 2.3 数组
                                              • 2.3.1 一维数组
                                                • 2.3.2 二维数组
                                                  • 2.3.3 字符数组
                                                  • 本章小结
                                                    • 习题
                                                    • 第3章 运算符与判定结构
                                                      • 3.1 运算符
                                                        • 3.1.1 算术运算符
                                                          • 3.1.2 赋值运算符
                                                            • 3.1.3 一元运算符
                                                              • 3.1.4 比较运算符
                                                                • 3.1.5 逻辑运算符
                                                                • 3.2 数据的输入与输出
                                                                  • 3.2.1 I/O流
                                                                    • 3.2.2 预定义的插入符与提取符
                                                                      • 3.2.3 简单的I/O格式控制
                                                                      • 3.3 条件结构
                                                                        • 3.3.1 if…else结构
                                                                          • 3.3.2 switch…case结构
                                                                          • 3.4 循环结构
                                                                            • 3.4.1 while循环
                                                                              • 3.4.2 do…while循环
                                                                                • 3.4.3 for循环
                                                                                  • 3.4.4 break与continue语句
                                                                                  • 本章小结
                                                                                    • 习题
                                                                                    • 第4章 函数与类
                                                                                      • 4.1 函数
                                                                                        • 4.1.1 函数的基本概念
                                                                                          • 4.1.2 形式参数和实际参数
                                                                                          • 4.2 访问区分符
                                                                                            • 4.2.1 抽象和封装
                                                                                              • 4.2.2 使用访问区分符实现抽象和封装
                                                                                              • 4.3 静态变量和静态函数
                                                                                                • 4.3.1 静态变量
                                                                                                  • 4.3.2 静态函数
                                                                                                  • 4.4 友元函数和友元类
                                                                                                    • 4.4.1 友元函数
                                                                                                      • 4.4.2 友元类
                                                                                                      • 本章小结
                                                                                                        • 习题
                                                                                                        • 第5章 构造函数和析构函数
                                                                                                          • 5.1 函数
                                                                                                            • 5.1.1 函数概述
                                                                                                              • 5.1.2 函数原型
                                                                                                                • 5.1.3 函数参数
                                                                                                                  • 5.1.4 默认参数
                                                                                                                  • 5.2 类的构造函数
                                                                                                                    • 5.2.1 类的初始化
                                                                                                                      • 5.2.2 构造函数的需要性
                                                                                                                        • 5.2.3 构造函数的使用
                                                                                                                          • 5.2.4 缺省构造函数
                                                                                                                            • 5.2.5 带参数的构造函数
                                                                                                                              • 5.2.6 重载构造函数
                                                                                                                                • 5.2.7 类成员初始化的问题
                                                                                                                                  • 5.2.8 构造类成员
                                                                                                                                    • 5.2.9 复制构造函数
                                                                                                                                    • 5.3 析构函数
                                                                                                                                      • 本章小结
                                                                                                                                        • 习题
                                                                                                                                        • 第6章 指针和引用
                                                                                                                                          • 6.1 指针变量的定义
                                                                                                                                            • 6.2 指针变量的引用
                                                                                                                                              • 6.3 地址运算
                                                                                                                                                • 6.4 指针和数组
                                                                                                                                                  • 6.4.1 指向数组元素的指针
                                                                                                                                                    • 6.4.2 指向二维数组的指针
                                                                                                                                                      • 6.4.3 指向一个由n个元素所组成的数组指针
                                                                                                                                                        • 6.4.4 字符指针
                                                                                                                                                          • 6.4.5 指针数组
                                                                                                                                                          • 6.5 指针与动态内存分配
                                                                                                                                                            • 6.6 引用
                                                                                                                                                              • 6.7 对引用使用地址操作符
                                                                                                                                                                • 6.8 引用对象
                                                                                                                                                                  • 6.9 用引用传递函数变量
                                                                                                                                                                    • 6.9.1 用指针使swap()工作
                                                                                                                                                                      • 6.9.2 用引用实现swap()
                                                                                                                                                                      • 6.10 返回多个值
                                                                                                                                                                        • 6.11 用引用返回值
                                                                                                                                                                          • 6.12 用引用传递提高效率
                                                                                                                                                                          • 本章小结
                                                                                                                                                                            • 习题
                                                                                                                                                                            • 第7章 继承
                                                                                                                                                                              • 7.1 继承的定义
                                                                                                                                                                                • 7.1.1 继承和派生
                                                                                                                                                                                  • 7.1.2 派生语法
                                                                                                                                                                                    • 7.1.3 私有与保护
                                                                                                                                                                                    • 7.2 构造函数与析构函数
                                                                                                                                                                                      • 7.3 向基类构造函数传递变量
                                                                                                                                                                                        • 7.4 重定义函数
                                                                                                                                                                                          • 7.5 多继承
                                                                                                                                                                                            • 7.5.1 多继承的工作原理
                                                                                                                                                                                              • 7.5.2 继承的模糊性
                                                                                                                                                                                                • 7.5.3 虚拟继承
                                                                                                                                                                                                  • 7.5.4 多继承的构造顺序
                                                                                                                                                                                                  • 7.6 私有继承
                                                                                                                                                                                                    • 本章小结
                                                                                                                                                                                                      • 习题
                                                                                                                                                                                                      • 第8章 多态性
                                                                                                                                                                                                        • 8.1 多态性概述
                                                                                                                                                                                                          • 8.1.1 多态的类型
                                                                                                                                                                                                            • 8.1.2 多态的实现
                                                                                                                                                                                                            • 8.2 函数重载
                                                                                                                                                                                                              • 8.3 运算符重载
                                                                                                                                                                                                                • 8.3.1 运算符重载为成员函数
                                                                                                                                                                                                                  • 8.3.2 运算符重载为友元函数
                                                                                                                                                                                                                  • 8.4 虚函数
                                                                                                                                                                                                                    • 8.4.1 一般虚函数成员
                                                                                                                                                                                                                      • 8.4.2 虚析构函数
                                                                                                                                                                                                                      • 8.5 抽象类
                                                                                                                                                                                                                        • 8.5.1 纯虚函数
                                                                                                                                                                                                                          • 8.5.2 抽象类
                                                                                                                                                                                                                          • 8.6 程序实例
                                                                                                                                                                                                                            • 8.6.1 运算符重载的实例
                                                                                                                                                                                                                              • 8.6.2 虚函数使用的实例
                                                                                                                                                                                                                              • 本章小结
                                                                                                                                                                                                                                • 习题
                                                                                                                                                                                                                                • 第9章 流类库与输入输出
                                                                                                                                                                                                                                  • 9.1 流及其类库简介
                                                                                                                                                                                                                                    • 9.2 标准输出
                                                                                                                                                                                                                                      • 9.2.1 使用预定义的插入符
                                                                                                                                                                                                                                        • 9.2.2 使用成员函数put()输出一个字符
                                                                                                                                                                                                                                          • 9.2.3 使用成员函数write()输出一个字符串
                                                                                                                                                                                                                                          • 9.3 标准输入
                                                                                                                                                                                                                                            • 9.3.1 使用预定义的提取符
                                                                                                                                                                                                                                              • 9.3.2 使用成员函数get()获取一个字符
                                                                                                                                                                                                                                                • 9.3.3 使用成员函数read()读取一个字符串
                                                                                                                                                                                                                                                • 9.4 格式化输入和输出
                                                                                                                                                                                                                                                  • 9.4.1 设置流的格式化标志
                                                                                                                                                                                                                                                    • 9.4.2 格式输出函数
                                                                                                                                                                                                                                                      • 9.4.3 操纵符
                                                                                                                                                                                                                                                      • 9.5 磁盘文件的输入和输出
                                                                                                                                                                                                                                                        • 9.5.1 磁盘文件的打开和关闭操作
                                                                                                                                                                                                                                                          • 9.5.2 文件的读写操作
                                                                                                                                                                                                                                                            • 9.5.3 随机访问数据文件
                                                                                                                                                                                                                                                            • 本章小结
                                                                                                                                                                                                                                                              • 习题
                                                                                                                                                                                                                                                              • 第10章 模板
                                                                                                                                                                                                                                                                • 10.1 概述
                                                                                                                                                                                                                                                                  • 10.2 函数模板
                                                                                                                                                                                                                                                                    • 10.2.1 模板说明
                                                                                                                                                                                                                                                                      • 10.2.2 函数模板的定义与实例化
                                                                                                                                                                                                                                                                        • 10.2.3 重载函数模板
                                                                                                                                                                                                                                                                        • 10.3 类模板
                                                                                                                                                                                                                                                                          • 10.3.1 类模板的定义与实例化
                                                                                                                                                                                                                                                                            • 10.3.2 类模板作为函数参数
                                                                                                                                                                                                                                                                              • 10.3.3 在类族中使用类模板
                                                                                                                                                                                                                                                                              • 10.4 关于类模板的一个完整例子
                                                                                                                                                                                                                                                                                • 10.5 C++标准模板库简介
                                                                                                                                                                                                                                                                                  • 10.5.1 与C++标准模板库有关的概念和术语
                                                                                                                                                                                                                                                                                    • 10.5.2 向量
                                                                                                                                                                                                                                                                                    • 10.6 名字空间
                                                                                                                                                                                                                                                                                      • 10.6.1 定义名字空间
                                                                                                                                                                                                                                                                                        • 10.6.2 名字空间的使用
                                                                                                                                                                                                                                                                                        • 本章小结
                                                                                                                                                                                                                                                                                          • 习题
                                                                                                                                                                                                                                                                                          • 第11章 异常处理
                                                                                                                                                                                                                                                                                            • 11.1 异常情况的产生
                                                                                                                                                                                                                                                                                              • 11.2 C++异常处理的实现
                                                                                                                                                                                                                                                                                                • 11.2.1 异常的抛出
                                                                                                                                                                                                                                                                                                  • 11.2.2 异常的捕获
                                                                                                                                                                                                                                                                                                    • 11.2.3 异常处理的执行过程
                                                                                                                                                                                                                                                                                                      • 11.2.4 异常规格说明
                                                                                                                                                                                                                                                                                                        • 11.2.5 异常的再抛出
                                                                                                                                                                                                                                                                                                        • 11.3 异常处理中的构造与析构
                                                                                                                                                                                                                                                                                                          • 本章小结
                                                                                                                                                                                                                                                                                                            • 习题
                                                                                                                                                                                                                                                                                                            • 附录1 C++中的关键字
                                                                                                                                                                                                                                                                                                              • 附录2 运算符优先级
                                                                                                                                                                                                                                                                                                                • 附录3 ASCII字符集

                                                                                                                                                                                                                                                                                                                相关图书