顶部
收藏

C++程序设计教程(第2版)


作者:
罗建军 朱丹军 顾刚 刘路放
定价:
35.00 元
版面字数:
620千字
开本:
16开
装帧形式:
平装
版次:
2
最新版次
印刷时间:
2021年
ISBN:
978-7-04-022080-3
物料号:
22080-00
出版时间:
2007-08-28
读者对象:
高等教育
一级分类:
计算机/教育技术类
二级分类:
计算机基础课程
三级分类:
程序设计技术

本书以“精讲多练”的方式介绍面向对象C++程序设计,主要内容包括C++编程基础(基本数据类型和表达式、控制结构、函数、指针等)和面向对象的程序设计(类和对象、继承与派生、多态性、模板和异常等)。在编写格式上,按以下8个主题精心组织内容:本章目标、授课内容、自学内容、程序设计举例、编程提示、实例编程、小结和习题,从而做到条理清楚,逻辑分明。

本书除了突出编程方法的讲解力度以外,还提供了大量有代表性的例题、实例和习题,在阐述面向对象理论的同时,突出了实践环节,切实使读者的独立编程能力得到提高。

本书可作为高等学校理工类各专业程序设计的教材或参考书,也可供应用程序开发人员学习参考。

  • 目录
    • 前辅文
      • 第1章 C++语言简介
        • 本章目标
          • 授课内容
            • 1.1 C++程序的基本结构
              • 1.2 算法与程序
                • 1.3 C++程序的基本要素
                  • 1.3.1 标识符、关键字和标点符号
                    • 1.3.2 注释
                      • 1.3.3 输入与输出
                      • 1.4 分析问题、编码、运行
                      • 自学内容
                        • 1.5 程序设计语言的发展
                          • 1.6 C++语言背景介绍
                          • 程序设计举例
                            • 编程提示
                              • 小结
                                • 习题
                                • 第2章 基本数据类型与表达式
                                  • 本章目标
                                    • 授课内容
                                      • 2.1 数据类型
                                        • 2.2 常量
                                          • 2.2.1 整型常量
                                            • 2.2.2 实型常量
                                              • 2.2.3 字符常量
                                                • 2.2.4 字符串常量
                                                  • 2.2.5 布尔型常量
                                                  • 2.3 变量
                                                    • 2.3.1 变量的定义
                                                      • 2.3.2 变量的初始化
                                                      • 2.4 运算符与表达式
                                                        • 2.4.1 算术运算符和算术表达式
                                                          • 2.4.2 关系运算符和关系表达式
                                                            • 2.4.3 逻辑运算符和逻辑表达式
                                                              • 2.4.4 赋值运算符和赋值表达式
                                                                • 2.4.5 自增运算符和自减运算符
                                                                • 2.5 表达式中各运算符的运算顺序
                                                                  • 2.6 类型不同的数据之间的混合算术运算
                                                                  • 自学内容
                                                                    • 2.7 类型修饰符
                                                                      • 2.8 typedef语句
                                                                        • 2.9 常量修饰符
                                                                          • 2.10 八进制和十六进制常量
                                                                            • 2.11 位运算表达式
                                                                              • 2.12 其他具有副作用的运算符
                                                                              • 程序设计举例
                                                                                • 编程提示
                                                                                  • 小结
                                                                                    • 习题
                                                                                    • 第3章 控制结构
                                                                                      • 本章目标
                                                                                        • 授课内容
                                                                                          • 3.1 程序的基本控制结构
                                                                                            • 3.2 C++的控制结构
                                                                                              • 3.2.1 顺序结构
                                                                                                • 3.2.2 选择结构
                                                                                                  • 3.2.3 循环结构
                                                                                                • 自学内容
                                                                                                  • 3.3 C++的其他控制转移语句
                                                                                                    • 3.4 表达式语句
                                                                                                    • 程序设计举例
                                                                                                      • 实例编程——模拟仿真
                                                                                                        • 编程提示
                                                                                                          • 小结
                                                                                                            • 习题
                                                                                                            • 第4章 数组与字符串
                                                                                                              • 本章目标
                                                                                                                • 授课内容
                                                                                                                  • 4.1 数组
                                                                                                                    • 4.1.1 一维数组
                                                                                                                      • 4.1.2 二维数组
                                                                                                                        • 4.1.3 多维数组
                                                                                                                        • 4.2 字符型数组和字符串处理库函数
                                                                                                                          • 4.2.1 字符型数组的定义和初始化
                                                                                                                            • 4.2.2 字符串的输入与输出
                                                                                                                              • 4.2.3 字符串处理库函数
                                                                                                                            • 自学内容
                                                                                                                              • 4.3 C++的string类
                                                                                                                              • 程序设计举例
                                                                                                                                • 实例编程——Josephus问题
                                                                                                                                  • 编程提示
                                                                                                                                    • 小结
                                                                                                                                      • 习题
                                                                                                                                      • 第5章 函数
                                                                                                                                        • 本章目标
                                                                                                                                          • 授课内容
                                                                                                                                            • 5.1 函数概述
                                                                                                                                              • 5.2 函数的定义
                                                                                                                                                • 5.3 函数的调用
                                                                                                                                                  • 5.4 函数间的参数传递
                                                                                                                                                    • 5.4.1 值调用
                                                                                                                                                      • 5.4.2 引用调用
                                                                                                                                                      • 5.5 函数与数组
                                                                                                                                                        • 5.6 局部变量和全局变量
                                                                                                                                                        • 自学内容
                                                                                                                                                          • 5.7 函数声明
                                                                                                                                                            • 5.8 带有默认参数的函数
                                                                                                                                                              • 5.9 C++的库函数
                                                                                                                                                                • 5.10 变量的存储类别
                                                                                                                                                                  • 5.10.1 自动变量
                                                                                                                                                                    • 5.10.2 静态变量
                                                                                                                                                                      • 5.10.3 寄存器变量
                                                                                                                                                                        • 5.10.4 外部变量
                                                                                                                                                                        • 5.11 多个源程序文件程序中的全局变量说明
                                                                                                                                                                          • 5.12 变量使用
                                                                                                                                                                          • 程序设计举例
                                                                                                                                                                            • 实例编程——万年历
                                                                                                                                                                              • 编程提示
                                                                                                                                                                                • 小结
                                                                                                                                                                                  • 习题
                                                                                                                                                                                  • 第6章 指针
                                                                                                                                                                                    • 本章目标
                                                                                                                                                                                      • 授课内容
                                                                                                                                                                                        • 6.1 地址与指针
                                                                                                                                                                                          • 6.1.1 地址
                                                                                                                                                                                            • 6.1.2 指针
                                                                                                                                                                                            • 6.2 指针运算
                                                                                                                                                                                              • 6.2.1 “*”和“&”运算符
                                                                                                                                                                                                • 6.2.2 指针变量算术运算
                                                                                                                                                                                                  • 6.2.3 指针变量比较运算
                                                                                                                                                                                                    • 6.2.4 指针变量下标运算
                                                                                                                                                                                                    • 6.3 指针与数组
                                                                                                                                                                                                      • 6.4 动态存储分配
                                                                                                                                                                                                      • 自学内容
                                                                                                                                                                                                        • 6.5 指针数组
                                                                                                                                                                                                          • 6.6 指向指针的指针
                                                                                                                                                                                                            • 6.7 指针的初始化
                                                                                                                                                                                                            • 程序设计举例
                                                                                                                                                                                                              • 实例编程——棋类游戏
                                                                                                                                                                                                                • 编程提示
                                                                                                                                                                                                                  • 小结
                                                                                                                                                                                                                    • 习题
                                                                                                                                                                                                                    • 第7章 函数与指针
                                                                                                                                                                                                                      • 本章目标
                                                                                                                                                                                                                        • 授课内容
                                                                                                                                                                                                                          • 7.1 递归函数
                                                                                                                                                                                                                            • 7.2 函数重载
                                                                                                                                                                                                                              • 7.3 指针和函数的关系
                                                                                                                                                                                                                                • 7.3.1 指针作为函数的参数
                                                                                                                                                                                                                                  • 7.3.2 返回指针的函数
                                                                                                                                                                                                                                    • 7.3.3 指向函数的指针
                                                                                                                                                                                                                                    • 7.4 带参数的main( )函数
                                                                                                                                                                                                                                    • 自学内容
                                                                                                                                                                                                                                      • 7.5 内联函数
                                                                                                                                                                                                                                        • 7.6 无参函数
                                                                                                                                                                                                                                          • 7.7 void和const类型的指针
                                                                                                                                                                                                                                          • 程序设计举例
                                                                                                                                                                                                                                            • 实例编程——最大子串和
                                                                                                                                                                                                                                              • 编程提示
                                                                                                                                                                                                                                                • 小结
                                                                                                                                                                                                                                                  • 习题
                                                                                                                                                                                                                                                  • 第8章 结构化设计方法
                                                                                                                                                                                                                                                    • 本章目标
                                                                                                                                                                                                                                                      • 授课内容
                                                                                                                                                                                                                                                        • 8.1 结构体类型
                                                                                                                                                                                                                                                          • 8.1.1 结构体类型的定义
                                                                                                                                                                                                                                                            • 8.1.2 结构体变量的初始化和使用
                                                                                                                                                                                                                                                            • 8.2 枚举类型
                                                                                                                                                                                                                                                              • 8.3 自顶向下、逐步求精的程序设计方法
                                                                                                                                                                                                                                                              • 自学内容
                                                                                                                                                                                                                                                                • 8.4 共用体
                                                                                                                                                                                                                                                                  • 8.5 数组和结构体
                                                                                                                                                                                                                                                                    • 8.5.1 结构体中的数组
                                                                                                                                                                                                                                                                      • 8.5.2 数组中的结构体
                                                                                                                                                                                                                                                                      • 8.6 结构体中的结构体
                                                                                                                                                                                                                                                                        • 8.7 结构体与指针
                                                                                                                                                                                                                                                                          • 8.8 编译预处理
                                                                                                                                                                                                                                                                            • 8.8.1 文件包含
                                                                                                                                                                                                                                                                              • 8.8.2 宏定义
                                                                                                                                                                                                                                                                                • 8.8.3 条件编译
                                                                                                                                                                                                                                                                                • 8.9 结构化程序设计方法的发展历史
                                                                                                                                                                                                                                                                                • 程序设计举例
                                                                                                                                                                                                                                                                                  • 实例编程——“验证”哥德巴赫猜想
                                                                                                                                                                                                                                                                                    • 编程提示
                                                                                                                                                                                                                                                                                      • 小结
                                                                                                                                                                                                                                                                                        • 习题
                                                                                                                                                                                                                                                                                        • 第9章 类和对象(一)
                                                                                                                                                                                                                                                                                          • 本章目标
                                                                                                                                                                                                                                                                                            • 授课内容
                                                                                                                                                                                                                                                                                              • 9.1 面向对象的基本概念
                                                                                                                                                                                                                                                                                                • 9.1.1 对象和面向对象
                                                                                                                                                                                                                                                                                                  • 9.1.2 面向对象的基本特征
                                                                                                                                                                                                                                                                                                  • 9.2 类与对象的声明和定义
                                                                                                                                                                                                                                                                                                    • 9.2.1 类的声明
                                                                                                                                                                                                                                                                                                      • 9.2.2 对象的定义
                                                                                                                                                                                                                                                                                                        • 9.2.3 类和对象的关系
                                                                                                                                                                                                                                                                                                        • 9.3 成员函数
                                                                                                                                                                                                                                                                                                          • 9.3.1 成员函数的定义
                                                                                                                                                                                                                                                                                                            • 9.3.2 内联成员函数
                                                                                                                                                                                                                                                                                                            • 9.4 对象的访问
                                                                                                                                                                                                                                                                                                              • 9.5 对象的存储
                                                                                                                                                                                                                                                                                                              • 自学内容
                                                                                                                                                                                                                                                                                                                • 9.6 类的组合
                                                                                                                                                                                                                                                                                                                  • 9.7 接口与实现方法的分离
                                                                                                                                                                                                                                                                                                                  • 程序设计举例
                                                                                                                                                                                                                                                                                                                    • 小结
                                                                                                                                                                                                                                                                                                                      • 习题
                                                                                                                                                                                                                                                                                                                      • 第10章 类和对象(二)
                                                                                                                                                                                                                                                                                                                        • 本章目标
                                                                                                                                                                                                                                                                                                                          • 授课内容
                                                                                                                                                                                                                                                                                                                            • 10.1 构造函数
                                                                                                                                                                                                                                                                                                                              • 10.1.1 对象初始化和构造函数
                                                                                                                                                                                                                                                                                                                                • 10.1.2 构造函数的重载
                                                                                                                                                                                                                                                                                                                                  • 10.1.3 数据成员的初始化方法
                                                                                                                                                                                                                                                                                                                                  • 10.2 析构函数
                                                                                                                                                                                                                                                                                                                                    • 10.3 对象与指针
                                                                                                                                                                                                                                                                                                                                      • 10.3.1 指向对象的指针
                                                                                                                                                                                                                                                                                                                                        • 10.3.2 指向对象成员的指针
                                                                                                                                                                                                                                                                                                                                          • 10.3.3 this指针
                                                                                                                                                                                                                                                                                                                                        • 自学内容
                                                                                                                                                                                                                                                                                                                                          • 10.4 string类的成员函数
                                                                                                                                                                                                                                                                                                                                          • 程序设计举例
                                                                                                                                                                                                                                                                                                                                            • 实例编程——职工档案管理系统
                                                                                                                                                                                                                                                                                                                                              • 小结
                                                                                                                                                                                                                                                                                                                                                • 习题
                                                                                                                                                                                                                                                                                                                                                • 第11章 继承
                                                                                                                                                                                                                                                                                                                                                  • 本章目标
                                                                                                                                                                                                                                                                                                                                                    • 授课内容
                                                                                                                                                                                                                                                                                                                                                      • 11.1 有关继承的基本概念
                                                                                                                                                                                                                                                                                                                                                        • 11.2 派生类
                                                                                                                                                                                                                                                                                                                                                          • 11.2.1 派生类的声明
                                                                                                                                                                                                                                                                                                                                                            • 11.2.2 派生类的构成
                                                                                                                                                                                                                                                                                                                                                            • 11.3 派生类的继承方式和访问属性
                                                                                                                                                                                                                                                                                                                                                              • 11.3.1 公有继承
                                                                                                                                                                                                                                                                                                                                                                • 11.3.2 私有继承
                                                                                                                                                                                                                                                                                                                                                                  • 11.3.3 保护继承
                                                                                                                                                                                                                                                                                                                                                                  • 11.4 派生类的构造函数和析构函数
                                                                                                                                                                                                                                                                                                                                                                    • 11.4.1 派生类的构造函数
                                                                                                                                                                                                                                                                                                                                                                      • 11.4.2 派生类的析构函数
                                                                                                                                                                                                                                                                                                                                                                    • 自学内容
                                                                                                                                                                                                                                                                                                                                                                      • 11.5 显式访问基类成员
                                                                                                                                                                                                                                                                                                                                                                      • 程序设计举例
                                                                                                                                                                                                                                                                                                                                                                        • 实例编程——象棋类
                                                                                                                                                                                                                                                                                                                                                                          • 小结
                                                                                                                                                                                                                                                                                                                                                                            • 习题
                                                                                                                                                                                                                                                                                                                                                                            • 第12章 多态性
                                                                                                                                                                                                                                                                                                                                                                              • 本章目标
                                                                                                                                                                                                                                                                                                                                                                                • 授课内容
                                                                                                                                                                                                                                                                                                                                                                                  • 12.1 多态性概述
                                                                                                                                                                                                                                                                                                                                                                                    • 12.2 派生类对象替换基类对象
                                                                                                                                                                                                                                                                                                                                                                                      • 12.3 虚函数
                                                                                                                                                                                                                                                                                                                                                                                        • 12.3.1 虚函数定义
                                                                                                                                                                                                                                                                                                                                                                                          • 12.3.2 虚函数的使用限制
                                                                                                                                                                                                                                                                                                                                                                                          • 12.4 抽象类
                                                                                                                                                                                                                                                                                                                                                                                            • 12.5 运算符重载
                                                                                                                                                                                                                                                                                                                                                                                            • 自学内容
                                                                                                                                                                                                                                                                                                                                                                                              • 12.6 const修饰符
                                                                                                                                                                                                                                                                                                                                                                                                • 12.7 静态成员
                                                                                                                                                                                                                                                                                                                                                                                                • 程序设计举例
                                                                                                                                                                                                                                                                                                                                                                                                  • 实例编程——较完整的日期类
                                                                                                                                                                                                                                                                                                                                                                                                    • 小结
                                                                                                                                                                                                                                                                                                                                                                                                      • 习题
                                                                                                                                                                                                                                                                                                                                                                                                      • 第13章 模板与异常处理
                                                                                                                                                                                                                                                                                                                                                                                                        • 本章目标
                                                                                                                                                                                                                                                                                                                                                                                                          • 授课内容
                                                                                                                                                                                                                                                                                                                                                                                                            • 13.1 模板
                                                                                                                                                                                                                                                                                                                                                                                                              • 13.1.1 函数模板
                                                                                                                                                                                                                                                                                                                                                                                                                • 13.1.2 类模板
                                                                                                                                                                                                                                                                                                                                                                                                                • 13.2 异常处理机制
                                                                                                                                                                                                                                                                                                                                                                                                                • 自学内容
                                                                                                                                                                                                                                                                                                                                                                                                                  • 13.3 友元
                                                                                                                                                                                                                                                                                                                                                                                                                    • 13.3.1 友元函数
                                                                                                                                                                                                                                                                                                                                                                                                                      • 13.3.2 友元类
                                                                                                                                                                                                                                                                                                                                                                                                                    • 程序设计举例
                                                                                                                                                                                                                                                                                                                                                                                                                      • 实例编程——矩阵类
                                                                                                                                                                                                                                                                                                                                                                                                                        • 小结
                                                                                                                                                                                                                                                                                                                                                                                                                          • 习题
                                                                                                                                                                                                                                                                                                                                                                                                                          • 第14章 标准库和输入/输出流
                                                                                                                                                                                                                                                                                                                                                                                                                            • 本章目标
                                                                                                                                                                                                                                                                                                                                                                                                                              • 授课内容
                                                                                                                                                                                                                                                                                                                                                                                                                                • 14.1 标准库概述
                                                                                                                                                                                                                                                                                                                                                                                                                                  • 14.2 流
                                                                                                                                                                                                                                                                                                                                                                                                                                    • 14.3 输入/输出流
                                                                                                                                                                                                                                                                                                                                                                                                                                      • 14.3.1 iostream类库的头文件
                                                                                                                                                                                                                                                                                                                                                                                                                                        • 14.3.2 输入/输出流类和对象
                                                                                                                                                                                                                                                                                                                                                                                                                                          • 14.3.3 输入/输出流的成员函数
                                                                                                                                                                                                                                                                                                                                                                                                                                          • 14.4 格式化I/O
                                                                                                                                                                                                                                                                                                                                                                                                                                            • 14.4.1 流格式状态标志和格式化函数
                                                                                                                                                                                                                                                                                                                                                                                                                                              • 14.4.2 流操纵符
                                                                                                                                                                                                                                                                                                                                                                                                                                              • 14.5 文件处理
                                                                                                                                                                                                                                                                                                                                                                                                                                                • 14.5.1 文件和流
                                                                                                                                                                                                                                                                                                                                                                                                                                                  • 14.5.2 打开和关闭文件
                                                                                                                                                                                                                                                                                                                                                                                                                                                    • 14.5.3 文件读/写
                                                                                                                                                                                                                                                                                                                                                                                                                                                      • 14.5.4 二进制文件
                                                                                                                                                                                                                                                                                                                                                                                                                                                        • 14.5.5 随机访问文件
                                                                                                                                                                                                                                                                                                                                                                                                                                                      • 自学内容
                                                                                                                                                                                                                                                                                                                                                                                                                                                        • 14.6 对象的输入/输出
                                                                                                                                                                                                                                                                                                                                                                                                                                                          • 14.7 名字空间
                                                                                                                                                                                                                                                                                                                                                                                                                                                          • 程序设计举例
                                                                                                                                                                                                                                                                                                                                                                                                                                                            • 小结
                                                                                                                                                                                                                                                                                                                                                                                                                                                              • 习题
                                                                                                                                                                                                                                                                                                                                                                                                                                                              • 第15章 链表
                                                                                                                                                                                                                                                                                                                                                                                                                                                                • 本章目标
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • 授课内容
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • 15.1 链表概述
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • 15.2 链表类
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • 自学内容
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • 15.3 顺序表
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • 程序设计举例
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • 小结
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • 习题
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • 第16章 程序设计与软件开发技术
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • 本章目标
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • 授课内容
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • 16.1 面向对象的程序设计方法
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • 16.2 案例分析——电话簿管理程序
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • 16.2.1 问题描述
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • 16.2.2 解决方案
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • 自学内容
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • 16.3 软件开发技术基础——软件生命周期
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • 16.4 标准模板库简介
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • 16.4.1 容器
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • 16.4.2 迭代器
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • 16.4.3 算法
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • 小结
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • 习题
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • 附录A ASCII码表
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • 附录B C++的技术支持
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • 参考文献

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    相关图书