顶部
收藏

C++ 程序设计


作者:
余苏宁
定价:
24.00 元
版面字数:
450千字
开本:
16开
装帧形式:
平装
版次:
1
最新版次
印刷时间:
2012年
ISBN:
978-7-04-012303-6
物料号:
12303-00
出版时间:
2004-01-28
读者对象:
高等教育
一级分类:
计算机/教育技术类
二级分类:
计算机基础课程
三级分类:
程序设计技术

全书系统地介绍了C/C++语言的基础知识、基本语法以及编程方法,深入浅出地讲述了C++语言面向对象的重要特征(抽象、封装、继承等)。全书共13章,主要内容包括:概论;数据类型、运算符与表达式;程序的结构与语句;数组与字符串;函数;指针;构造数据类型;非面向对象的拓展;类;继承与派生;多态与动态联编;运算符重载的实例;模板。

本书的特点是定位准确、选材适当,实例丰富、重点突出,特别适合作为应用型本科、高职高专院校计算机及相关专业学生学习C++程序设计的教材,也可作为其他理工科专业C++程序设计的教材,也适合作为相关技术人员的自学参考书。

书中所有程序全部运行通过,所有程序源代码及相关文档,包括综合性示例程序(时钟、人工生命、带回朔的迷宫探索)在两种开发环境(Borland C++3.1和Visual C++6.0)下的创建过程说明和源程序清单以及有关的教学资料(包括教学电子教案),均可以从高等教育出版社网站上下载,网址为:http:// cs.hep.com.cn或http://www.hep.edu.cn。

  • 目录
    • 第1章 概论
      • 1.1 C++程序演示
        • 1.2 C++程序的结构
          • 1.2.1 简单的C++程序
            • 1.2.2 C++程序的结构
              • 1.2.3 C++源程序的编辑、编译、链接和运行
              • 1.3 C++集成开发环境的安装与运行
                • 1.3.1 系统配置
                  • 1.3.2 VisualC++6.0集成开发环境的安装
                    • 1.3.3 VisualC++6.0集成开发环境的使用
                      • 1.4 面向对象技术的形成、发展和C++的诞生
                      • 1.5 C++的主要特点概述
                        • 习题一
                        • 第2章 数据类型、运算符与表达式
                          • 2.1 基本字符、标识符和关键字
                            • 2.1.1 基本字符
                              • 2.1.2 标识符
                                • 2.1.3 关键字(保留字)
                                • 2.2 数据与数据类型
                                  • 2.2.1 常量和变量
                                    • 2.2.2 基本类型
                                      • 2.2.3 数据类型转换
                                      • 2.3 表达式与运算符
                                        • 2.3.1 赋值运算符
                                          • 2.3.2 算术运算符
                                            • 2.3.3 自增(减)运算符
                                              • 2.3.4 关系运算符
                                                • 2.3.5 逻辑运算符
                                                  • 2.3.6 条件运算符
                                                    • 2.3.7 逗号运算符
                                                      • 2.3.8 位运算符
                                                        • 2.3.9 算术、关系、逻辑、赋值混合运算
                                                          • 2.3.10 运算顺序与副作用
                                                          • 习题二
                                                          • 第3章 程序的结构与语句
                                                            • 3.1 程序结构与语句概述
                                                              • 3.2 顺序结构
                                                                • 3.3 选择结构
                                                                  • 3.3.1 if语句(条件语句)
                                                                    • 3.3.2 switch语句(开关语句)和break语句
                                                                    • 3.4 循环结构
                                                                      • 3.4.1 当型循环(while循环)
                                                                        • 3.4.2 直到型循环(do-while循环)
                                                                          • 3.4.3 计数循环(for循环)
                                                                            • 3.4.4 循环的嵌套
                                                                              • 3.4.5 continue语句
                                                                                • 3.4.6 goto语句和标号语句
                                                                                • 习题三
                                                                                • 第4章 数组与字符串
                                                                                  • 4.1 数组概述
                                                                                    • 4.2 一维数组
                                                                                      • 4.2.1 一维数组的定义和引用
                                                                                        • 4.2.2 一维数组的初始化
                                                                                          • 4.2.3 一维数组应用举例
                                                                                          • 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 字符型数组应用举例
                                                                                                        • 习题四
                                                                                                        • 第5章 函数与预处理
                                                                                                          • 5.1 函数定义和声明
                                                                                                            • 5.1.1 函数的定义
                                                                                                              • 5.1.2 函数的声明
                                                                                                              • 5.2 参数种类和参数传递方式
                                                                                                                • 5.3 函数调用
                                                                                                                  • 5.4 函数的嵌套调用和递归调用
                                                                                                                    • 5.4.1 函数的嵌套调用
                                                                                                                      • 5.4.2 函数的递归调用和递归函数
                                                                                                                      • 5.5 存储属性
                                                                                                                        • 5.5.1 作用域
                                                                                                                          • 5.5.2 存储类别
                                                                                                                          • 5.6 内部函数与外部函数
                                                                                                                            • 5.6.1 内部函数
                                                                                                                              • 5.6.2 外部函数
                                                                                                                              • 5.7 预处理
                                                                                                                                • 5.7.1 宏定义
                                                                                                                                  • 5.7.2 文件包含
                                                                                                                                    • 5.7.3 条件编译
                                                                                                                                    • 习题五
                                                                                                                                    • 第6章 指针
                                                                                                                                      • 6.1 指针和指针变量
                                                                                                                                        • 6.2 指针变量的定义和使用
                                                                                                                                          • 6.2.1 指针变量的定义和使用
                                                                                                                                            • 6.2.2 指针变量作函数参数
                                                                                                                                              • 6.2.3 指向指针的指针和指针所指向的类型
                                                                                                                                              • 6.3 指针与数组
                                                                                                                                                • 6.3.1 数组的指针和数组元素的指针
                                                                                                                                                  • 6.3.2 指针与一维数组
                                                                                                                                                    • 6.3.3 指向数组的指针作函数参数
                                                                                                                                                      • 6.3.4 指针与二维数组
                                                                                                                                                        • 6.3.5 动态数组与动态存储分配
                                                                                                                                                          • 6.3.6 指针数组
                                                                                                                                                          • 6.4 指针与字符串
                                                                                                                                                            • 6.5 指针与函数
                                                                                                                                                              • 6.5.1 返回指针值的函数
                                                                                                                                                                • 6.5.2 指向函数的指针
                                                                                                                                                                  • 6.5.3 指向函数的指针作函数参数
                                                                                                                                                                    • 6.5.4 main函数的参数
                                                                                                                                                                    • 6.6 有关指针的数据类型小结
                                                                                                                                                                      • 习题六
                                                                                                                                                                      • 第7章 构造数据类型
                                                                                                                                                                        • 7.1 结构型
                                                                                                                                                                          • 7.1.1 结构型、结构型变量及结构型指针的定义
                                                                                                                                                                            • 7.1.2 结构型的嵌套和匿名结构型
                                                                                                                                                                              • 7.1.3 访问结构型变量
                                                                                                                                                                                • 7.1.4 结构型变量的初始化
                                                                                                                                                                                  • 7.1.5 结构型数组
                                                                                                                                                                                    • 7.1.6 结构、指针与函数
                                                                                                                                                                                      • 7.1.7 综合应用
                                                                                                                                                                                      • 7.2 共用型
                                                                                                                                                                                        • 7.2.1 共用型的定义和共用型变量、指针的定义
                                                                                                                                                                                          • 7.2.2 共用型变量、指针的使用
                                                                                                                                                                                          • 7.3 枚举型
                                                                                                                                                                                            • 7.4 类型定义(typedef)
                                                                                                                                                                                              • 习题七
                                                                                                                                                                                              • 第8章 非面向对象的拓展
                                                                                                                                                                                                • 8.1 单行注释
                                                                                                                                                                                                  • 8.2 块(分程序)内任何位置定义和声明
                                                                                                                                                                                                    • 8.3 强制类型转换
                                                                                                                                                                                                      • 8.4 流式I/O
                                                                                                                                                                                                        • 8.5 函数的缺省参数
                                                                                                                                                                                                          • 8.6 内联函数
                                                                                                                                                                                                            • 8.7 函数重载
                                                                                                                                                                                                              • 8.8 引用
                                                                                                                                                                                                                • 8.8.1 独立引用
                                                                                                                                                                                                                  • 8.8.2 引用参数
                                                                                                                                                                                                                    • 8.8.3 返回引用的函数
                                                                                                                                                                                                                    • 8.9 const
                                                                                                                                                                                                                      • 8.9.1 const类型说明符
                                                                                                                                                                                                                        • 8.9.2 指针与常量
                                                                                                                                                                                                                          • 8.10 单目作用域运算符
                                                                                                                                                                                                                            • 8.11 动态存储分配与释放
                                                                                                                                                                                                                            • 习题八
                                                                                                                                                                                                                            • 第9章 类
                                                                                                                                                                                                                              • 9.1 类概念的引入和类的定义
                                                                                                                                                                                                                                • 9.2 类作用域
                                                                                                                                                                                                                                  • 9.3 数据成员与方法
                                                                                                                                                                                                                                    • 9.3.1 方法的定义和引用
                                                                                                                                                                                                                                      • 9.3.2 内联方法
                                                                                                                                                                                                                                        • 9.3.3 方法重载
                                                                                                                                                                                                                                          • 9.3.4 const对象和const成员函数
                                                                                                                                                                                                                                            • 9.4.2 析构函数
                                                                                                                                                                                                                                              • 9.4.3 缺省构造函数
                                                                                                                                                                                                                                                • 9.4.4 拷贝构造函数
                                                                                                                                                                                                                                                • 9.5 成员对象和对象数组
                                                                                                                                                                                                                                                  • 9.5.1 成员对象
                                                                                                                                                                                                                                                    • 9.5.2 对象数组
                                                                                                                                                                                                                                                    • 9.6 类与指针
                                                                                                                                                                                                                                                      • 9.6.1 指向类对象的指针
                                                                                                                                                                                                                                                        • 9.6.2 this指针
                                                                                                                                                                                                                                                          • 9.6.3 指向类成员的指针
                                                                                                                                                                                                                                                          • 9.7 静态类成员
                                                                                                                                                                                                                                                            • 9.8 接口和实现的分离
                                                                                                                                                                                                                                                              • 习题九
                                                                                                                                                                                                                                                                • 第10章 继承与派生
                                                                                                                                                                                                                                                                  • 10.1 派生
                                                                                                                                                                                                                                                                    • 10.1.1 基类、派生类与继承
                                                                                                                                                                                                                                                                      • 10.1.2 派生类的继承特性
                                                                                                                                                                                                                                                                      • 10.2 多重继承
                                                                                                                                                                                                                                                                        • 10.3 虚拟基类
                                                                                                                                                                                                                                                                          • 10.4 派生类构造函数的定义方法
                                                                                                                                                                                                                                                                            • 习题十
                                                                                                                                                                                                                                                                            • 第11章 多态与动态联编
                                                                                                                                                                                                                                                                              • 11.1 虚拟函数、动态多态性与动态联编
                                                                                                                                                                                                                                                                                • 11.2 虚拟函数的访问属性
                                                                                                                                                                                                                                                                                  • 11.3 纯虚拟函数与抽象类
                                                                                                                                                                                                                                                                                    • 11.4 虚拟函数应用举例
                                                                                                                                                                                                                                                                                      • 11.4.1 产品管理程序的非多态解
                                                                                                                                                                                                                                                                                        • 11.4.2 产品管理程序的多态解
                                                                                                                                                                                                                                                                                          • 11.4.3 非多态解和多态解系统的维护
                                                                                                                                                                                                                                                                                          • 11.5 虚拟析构函数
                                                                                                                                                                                                                                                                                            • 11.6 动态联编的实现机理
                                                                                                                                                                                                                                                                                              • 习题十一
                                                                                                                                                                                                                                                                                              • 第12章 运算符重载
                                                                                                                                                                                                                                                                                                • 12.1 引入运算符重载的必要性
                                                                                                                                                                                                                                                                                                  • 12.2 运算符重载的规则
                                                                                                                                                                                                                                                                                                    • 12.3 含有指针数据成员的运算符重载
                                                                                                                                                                                                                                                                                                      • 12.4 用户定义的转换
                                                                                                                                                                                                                                                                                                        • 12.5 下标运算符重载
                                                                                                                                                                                                                                                                                                          • 12.6 运算符重载的实例
                                                                                                                                                                                                                                                                                                            • 习题十二
                                                                                                                                                                                                                                                                                                            • 第13章 模板
                                                                                                                                                                                                                                                                                                              • 13.1 类模板
                                                                                                                                                                                                                                                                                                                • 13.2 函数模板
                                                                                                                                                                                                                                                                                                                  • 13.3 特殊版本的模板
                                                                                                                                                                                                                                                                                                                    • 13.4 模板友元
                                                                                                                                                                                                                                                                                                                      • 13.5 编程示例
                                                                                                                                                                                                                                                                                                                        • 习题十三
                                                                                                                                                                                                                                                                                                                        • 附录A C/C++与BorlandC++3.l中的关键字表
                                                                                                                                                                                                                                                                                                                          • 附录B 运算符的优先级和结合性
                                                                                                                                                                                                                                                                                                                            • 附录C BorlandC++3.1独立图形运行程序的建立
                                                                                                                                                                                                                                                                                                                              • 参考文献

                                                                                                                                                                                                                                                                                                                              相关图书