顶部
收藏

C++: 面向对象程序设计(第2版)

“十一五”国家规划教材

作者:
李涛 杨剑波
定价:
35.00 元
版面字数:
570千字
开本:
16开
装帧形式:
平装
版次:
2
最新版次
印刷时间:
2023年
ISBN:
978-7-04-037679-1
物料号:
37679-00
出版时间:
2013-06-25
读者对象:
高等教育
一级分类:
计算机/教育技术类
二级分类:
计算机类专业核心课程
三级分类:
程序设计基础

本书全面系统地介绍了面向对象程序设计的基本思想、机制、要素和原理,详细介绍了C++面向对象程序设计技术;对MFC 应用程序框架作了专门介绍,力图在介绍基本原理的同时满足动手训练的需要。书后附Visual C++6.0 编译器使用方法和两套C++面向对象程序设计模拟试题,供读者学习本课程使用。本书将C++的基本原理与具体实践相结合,不仅让读者对C++语言本身有深刻的了解,也为读者迅速掌握流行的VC++程序设计工具打下了良好的基础。

本书取材新颖、内容丰富、可读性强,所设计的示例程序立足于方便读者观察C++相关机制的运行过程。

本书可作为高等院校计算机类专业本科生和研究生的教材,亦可供其他从事软件开发工作的读者参考。

  • 目录
    • 前辅文
      • 第1 章 C++基础知识
        • 1.1 C++语言简介
          • 1.1.1 C++的诞生和发展
            • 1.1.2 C++的基本特性
            • 1.2 C++对C 的扩充
              • 1.2.1 新的输入输出方式
                • 1.2.2 注释、变量声明与作用域限定符
                  • 1.2.3 强制类型转换与const 标识符
                    • 1.2.4 函数原型声明
                      • 1.2.5 内联函数
                        • 1.2.6 函数重载
                          • 1.2.7 带默认参数的函数
                            • 1.2.8 引用
                              • 1.2.9 运算符new 和delete
                                • 1.2.10 布尔类型
                                • 1.3 C++程序的开发过程
                                  • 1.3.1 一个简单的C++程序
                                    • 1.3.2 C++程序的开发
                                    • 习题1
                                    • 第2 章 C++类和对象
                                      • 2.1 面向对象程序设计方法概述
                                        • 2.1.1 面向对象程序设计方法的基本概念
                                          • 2.1.2 面向对象程序设计方法的基本原理
                                          • 2.2 类和对象
                                            • 2.2.1 类的定义
                                              • 2.2.2 成员函数的实现
                                                • 2.2.3 对象的创建
                                                  • 2.2.4 类成员的访问
                                                  • 2.3 构造函数和析构函数
                                                    • 2.3.1 构造函数
                                                      • 2.3.2 重载构造函数
                                                        • 2.3.3 带默认参数的构造函数
                                                          • 2.3.4 拷贝构造函数
                                                            • 2.3.5 析构函数
                                                            • 2.4 对象数组
                                                              • 2.5 对象指针
                                                                • 2.5.1 指向对象的指针
                                                                  • 2.5.2 this 指针
                                                                  • 2.6 静态成员
                                                                    • 2.6.1 静态数据成员
                                                                      • 2.6.2 静态成员函数
                                                                      • 2.7 友元关系
                                                                        • 2.7.1 友元函数
                                                                          • 2.7.2 友元类
                                                                          • 2.8 共享数据的保护
                                                                            • 2.8.1 常引用
                                                                              • 2.8.2 常对象
                                                                                • 2.8.3 常成员
                                                                                • *2.9 应用实例:员工信息管理系统
                                                                                  • 习题2
                                                                                  • 第3 章 继承
                                                                                    • 3.1 类的继承与派生
                                                                                      • 3.1.1 继承与派生的概念
                                                                                        • 3.1.2 派生类的定义
                                                                                        • 3.2 继承方式
                                                                                          • 3.2.1 公有继承
                                                                                            • 3.2.2 私有继承
                                                                                              • 3.2.3 保护继承
                                                                                              • 3.3 派生类的构造函数和析构函数
                                                                                                • 3.3.1 派生类的构造函数
                                                                                                  • 3.3.2 析构函数
                                                                                                  • 3.4 多继承
                                                                                                    • 3.4.1 多继承的声明
                                                                                                      • 3.4.2 多继承的构造函数
                                                                                                        • 3.4.3 多继承中的二义性问题
                                                                                                        • 3.5 虚基类
                                                                                                          • 3.5.1 虚基类的作用
                                                                                                            • 3.5.2 虚基类的初始化
                                                                                                            • 3.6 组合类
                                                                                                              • 3.6.1 组合类的概念
                                                                                                                • 3.6.2 组合类中的构造函数
                                                                                                                • *3.7 继承应用实例
                                                                                                                  • 3.7.1 问题描述
                                                                                                                    • 3.7.2 完整源程序
                                                                                                                      • 3.7.3 运行结果
                                                                                                                      • 习题3
                                                                                                                      • 第4 章 多态性
                                                                                                                        • 4.1 多态性
                                                                                                                          • 4.2 虚函数
                                                                                                                            • 4.2.1 虚函数的概念
                                                                                                                              • 4.2.2 必须使用虚函数的例子
                                                                                                                                • 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 全局函数重载
                                                                                                                                                • 4.4.3 函数的默认参数
                                                                                                                                                  • 4.4.4 二义性问题
                                                                                                                                                    • 4.4.5 虚函数与函数重载的关系
                                                                                                                                                    • 4.5 运算符重载
                                                                                                                                                      • 4.5.1 运算符重载的意义
                                                                                                                                                        • 4.5.2 运算符重载的规则
                                                                                                                                                          • 4.5.3 成员和非成员运算符函数重载
                                                                                                                                                            • 4.5.4 单目和双目运算符函数重载
                                                                                                                                                              • 4.5.5 赋值运算符重载和拷贝构造函数
                                                                                                                                                                • 4.5.6 其他运算符重载
                                                                                                                                                                  • *4.5.7 综合举例
                                                                                                                                                                  • 习题4
                                                                                                                                                                  • 第5 章 模板
                                                                                                                                                                    • 5.1 模板的基本概念和作用
                                                                                                                                                                      • 5.2 函数模板及模板函数
                                                                                                                                                                        • 5.2.1 函数模板定义及其实例化
                                                                                                                                                                          • 5.2.2 重载函数模板
                                                                                                                                                                          • 5.3 类模板及模板类
                                                                                                                                                                            • 5.3.1 类模板定义及其实例化
                                                                                                                                                                              • 5.3.2 类模板的派生
                                                                                                                                                                              • *5.4 模板实例
                                                                                                                                                                                • 习题5
                                                                                                                                                                                • *第6 章 标准模板库
                                                                                                                                                                                  • 6.1 标准模板库概述
                                                                                                                                                                                    • 6.1.1 标准模板库发展简介
                                                                                                                                                                                      • 6.1.2 标准模板库的主要内容
                                                                                                                                                                                      • 6.2 迭代器
                                                                                                                                                                                        • 6.2.1 迭代器的起源
                                                                                                                                                                                          • 6.2.2 迭代器类模板位置
                                                                                                                                                                                            • 6.2.3 迭代器的编程思想
                                                                                                                                                                                            • 6.3 函数对象
                                                                                                                                                                                              • 6.3.1 从函数到函数对象
                                                                                                                                                                                                • 6.3.2 系统函数对象类模板
                                                                                                                                                                                                • 6.4 常用通用容器
                                                                                                                                                                                                  • 6.4.1 vector 容器
                                                                                                                                                                                                    • 6.4.2 list 容器
                                                                                                                                                                                                      • 6.4.3 deque 容器
                                                                                                                                                                                                        • 6.4.4 queue 和stack 容器 ?
                                                                                                                                                                                                        • 6.5 STL 常用算法
                                                                                                                                                                                                          • 6.5.1 遍历容器算法for_each( ) ?
                                                                                                                                                                                                            • 6.5.2 查询算法find( )
                                                                                                                                                                                                              • 6.5.3 排序算法sort( )
                                                                                                                                                                                                              • 6.6 应用实例:列车调度 ?
                                                                                                                                                                                                                • 6.6.1 问题描述
                                                                                                                                                                                                                  • 6.6.2 分析
                                                                                                                                                                                                                    • 6.6.3 实现步骤
                                                                                                                                                                                                                      • 6.6.4 运行程序
                                                                                                                                                                                                                      • 习题6
                                                                                                                                                                                                                      • 第7 章 C++输入/输出
                                                                                                                                                                                                                        • 7.1 输入流与输出流基础
                                                                                                                                                                                                                          • 7.2 标准输出流对象cout
                                                                                                                                                                                                                            • 7.3 标准输入流对象cin
                                                                                                                                                                                                                              • 7.4 文件操作与文件流
                                                                                                                                                                                                                                • 7.4.1 文件和文件流基础
                                                                                                                                                                                                                                  • 7.4.2 文件的打开与关闭操作
                                                                                                                                                                                                                                    • 7.4.3 文本文件
                                                                                                                                                                                                                                      • 7.4.4 二进制文件
                                                                                                                                                                                                                                      • *7.5 应用实例:扩展C++
                                                                                                                                                                                                                                        • 7.5.1 问题描述
                                                                                                                                                                                                                                          • 7.5.2 分析
                                                                                                                                                                                                                                            • 7.5.3 实现步骤
                                                                                                                                                                                                                                              • 7.5.4 运行程序
                                                                                                                                                                                                                                              • 习题7
                                                                                                                                                                                                                                              • 第8 章 C++高级主题
                                                                                                                                                                                                                                                • 8.1 动态内存管理
                                                                                                                                                                                                                                                  • 8.1.1 new 运算符和delete 运算符的作用
                                                                                                                                                                                                                                                    • 8.1.2 重载new 和delete 运算符
                                                                                                                                                                                                                                                      • 8.1.3 常见动态内存错误
                                                                                                                                                                                                                                                        • 8.1.4 指针和数组的差异
                                                                                                                                                                                                                                                          • 8.1.5 利用指针传递内存
                                                                                                                                                                                                                                                          • 8.2 类型转换
                                                                                                                                                                                                                                                            • 8.3 异常处理
                                                                                                                                                                                                                                                              • 8.4 命名空间
                                                                                                                                                                                                                                                                • 习题8
                                                                                                                                                                                                                                                                • *第9 章 MFC 开发
                                                                                                                                                                                                                                                                  • 9.1 MFC 简介
                                                                                                                                                                                                                                                                    • 9.2 MFC 的主要类
                                                                                                                                                                                                                                                                      • 9.2.1 MFC 类库中的主要类
                                                                                                                                                                                                                                                                        • 9.2.2 可视对象类
                                                                                                                                                                                                                                                                        • 9.3 MFC 的消息与消息处理方法
                                                                                                                                                                                                                                                                          • 9.4 应用程序向导AppWizard 与类向导ClassWizard
                                                                                                                                                                                                                                                                            • 9.4.1 应用程序向导AppWizard
                                                                                                                                                                                                                                                                              • 9.4.2 类向导ClassWizard
                                                                                                                                                                                                                                                                              • *9.5 应用实例:人事管理
                                                                                                                                                                                                                                                                                • 9.5.1 问题描述
                                                                                                                                                                                                                                                                                  • 9.5.2 分析
                                                                                                                                                                                                                                                                                    • 9.5.3 实现步骤
                                                                                                                                                                                                                                                                                      • 9.5.4 运行程序
                                                                                                                                                                                                                                                                                      • 习题9
                                                                                                                                                                                                                                                                                      • 附录
                                                                                                                                                                                                                                                                                        • 附录A Visual C++ 6.0 编译器使用方法
                                                                                                                                                                                                                                                                                          • 附录B C++面向对象程序设计模拟试题
                                                                                                                                                                                                                                                                                            • B.1 模拟试题一
                                                                                                                                                                                                                                                                                              • B.2 模拟试题一参考答案
                                                                                                                                                                                                                                                                                                • B.3 模拟试题二
                                                                                                                                                                                                                                                                                                  • B.4 模拟试题二参考答案
                                                                                                                                                                                                                                                                                                • 参考文献

                                                                                                                                                                                                                                                                                                相关图书