顶部
收藏

全国计算机等级考试二级教程——C++语言程序设计


作者:
教育部教育考试院
定价:
45.00 元
版面字数:
0千字
开本:
16开
装帧形式:
平装
版次:
1
最新版次
印刷时间:
1899年
ISBN:
978-7-04-057682-5
物料号:
57682-A0
出版时间:
2022-02-28
读者对象:
考试用书
一级分类:
计算机考试
二级分类:
全国计算机等级考试(NCRE)
三级分类:
计算机等考二级

本书根据教育部教育考试院最新颁布的《全国计算机等级考试二级C++语言程序设计考试大纲》的要求,在上一版教程的基础上将开发环境升级到Visual C++ 2010 Express,是在全国计算机等级考试委员会指导下,由教育部教育考试院组织编写的计算机等级考试系列教程之一。其主要内容包括:C++的数据类型、基本语句、数组指针和引用、函数的使用、类与对象的相关知识,此外还介绍了模板和输入输出流。本书内容精练,结构合理,便于自学,对读者可能遇到的难点做了十分系统、清楚的阐述,除可以作为计算机等级考试用书外,也可以作为学习C++语言的参考书。

  • 目录
    • 前辅文
      • 第1章 C++语言概述
        • 1.1 C++语言的发展
          • 1.2 C++语言的特点
            • 1.3 面向对象程序设计
              • 1.4 C++语言的基本符号
                • 1.5 C++语言的词汇
                  • 1.5.1 关键字
                    • 1.5.2 标识符
                      • 1.5.3 字面常量
                        • 1.5.4 运算符
                          • 1.5.5 标点符号
                          • 1.6 C++程序的基本框架
                            • 1.7 C++程序的开发过程
                              • 1.7.1 编辑
                                • 1.7.2 编译
                                  • 1.7.3 连接
                                    • 1.7.4 运行和调试
                                    • 本章小结
                                      • 习题
                                      • 第2章 数据类型、运算符和表达式
                                        • 2.1 C++语言的数据类型
                                          • 2.1.1 基本类型
                                            • 2.1.2 基本类型的派生类型
                                            • 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.3.3 符号常量声明语句
                                                            • 2.4 运算符和表达式
                                                              • 2.4.1 运算符和表达式的概念
                                                                • 2.4.2 运算类型与运算符
                                                                  • 2.4.3 赋值运算
                                                                    • 2.4.4 算术运算符和算术表达式
                                                                      • 2.4.5 关系运算符和关系表达式
                                                                        • 2.4.6 逻辑运算符和逻辑表达式
                                                                          • 2.4.7 位运算符
                                                                            • 2.4.8 其他运算符
                                                                              • 2.4.9 优先级和结合性
                                                                              • 本章小结
                                                                                • 习题
                                                                                • 第3章 基本控制结构
                                                                                  • 3.1 C++语句
                                                                                    • 3.2 顺序结构
                                                                                      • 3.2.1 声明语句
                                                                                        • 3.2.2 表达式语句
                                                                                          • 3.2.3 基本输入输出
                                                                                            • 3.2.4 复合语句和空语句
                                                                                            • 3.3 选择结构
                                                                                              • 3.3.1 if语句
                                                                                                • 3.3.2 switch语句
                                                                                                • 3.4 循环结构
                                                                                                  • 3.4.1 for语句
                                                                                                    • 3.4.2 while语句
                                                                                                      • 3.4.3 do…while语句
                                                                                                        • 3.4.4 循环的嵌套
                                                                                                        • 3.5 跳转语句
                                                                                                          • 3.5.1 break语句
                                                                                                            • 3.5.2 continue语句
                                                                                                              • 3.5.3 return语句
                                                                                                                • 3.5.4 goto语句
                                                                                                                • 本章小结
                                                                                                                  • 习题
                                                                                                                  • 第4章 数组、指针与引用
                                                                                                                    • 4.1 数组
                                                                                                                      • 4.1.1 一维数组
                                                                                                                        • 4.1.2 多维数组
                                                                                                                          • 4.1.3 字符数组
                                                                                                                          • 4.2 指针
                                                                                                                            • 4.2.1 指针和地址
                                                                                                                              • 4.2.2 指针和数组
                                                                                                                                • 4.2.3 空指针、无类型指针和const指针
                                                                                                                                • 4.3 引用
                                                                                                                                  • 4.4 动态存储分配
                                                                                                                                    • 本章小结
                                                                                                                                      • 习题
                                                                                                                                      • 第5章 函数
                                                                                                                                        • 5.1 函数定义
                                                                                                                                          • 5.2 函数调用
                                                                                                                                            • 5.3 函数原型
                                                                                                                                              • 5.4 函数返回类型
                                                                                                                                                • 5.5 函数参数
                                                                                                                                                  • 5.5.1 参数的传递方式
                                                                                                                                                    • 5.5.2 默认参数
                                                                                                                                                    • 5.6 函数重载
                                                                                                                                                      • 5.7 内联函数
                                                                                                                                                        • 5.8 递归函数
                                                                                                                                                          • 5.9 变量的生存周期
                                                                                                                                                            • 本章小结
                                                                                                                                                              • 习题
                                                                                                                                                              • 第6章 类和对象
                                                                                                                                                                • 6.1 类的定义
                                                                                                                                                                  • 6.1.1 类的定义
                                                                                                                                                                    • 6.1.2 类成员的访问控制
                                                                                                                                                                      • 6.1.3 类的数据成员
                                                                                                                                                                        • 6.1.4 类的成员函数
                                                                                                                                                                        • 6.2 对象的定义
                                                                                                                                                                          • 6.2.1 对象的定义
                                                                                                                                                                            • 6.2.2 对象的成员
                                                                                                                                                                            • 6.3 构造函数和析构函数
                                                                                                                                                                              • 6.3.1 构造函数和析构函数的定义
                                                                                                                                                                                • 6.3.2 默认构造函数和默认析构函数
                                                                                                                                                                                  • 6.3.3 复制构造函数
                                                                                                                                                                                  • 6.4 自由存储对象
                                                                                                                                                                                    • 6.5 this指针
                                                                                                                                                                                      • 6.6 静态成员
                                                                                                                                                                                        • 6.6.1 静态数据成员
                                                                                                                                                                                          • 6.6.2 静态成员函数
                                                                                                                                                                                          • 6.7 常成员
                                                                                                                                                                                            • 6.7.1 常对象
                                                                                                                                                                                              • 6.7.2 常成员函数
                                                                                                                                                                                                • 6.7.3 常数据成员
                                                                                                                                                                                                • 6.8 友元
                                                                                                                                                                                                  • 6.8.1 友元函数
                                                                                                                                                                                                    • 6.8.2 友元类
                                                                                                                                                                                                    • 6.9 对象数组
                                                                                                                                                                                                      • 6.10 成员对象
                                                                                                                                                                                                        • 本章小结
                                                                                                                                                                                                          • 习题
                                                                                                                                                                                                          • 第7章 继承和派生
                                                                                                                                                                                                            • 7.1 继承与派生
                                                                                                                                                                                                              • 7.1.1 基本概念
                                                                                                                                                                                                                • 7.1.2 派生类的定义与构成
                                                                                                                                                                                                                • 7.2 派生类对基类成员的访问
                                                                                                                                                                                                                  • 7.3 派生类的构造函数和析构函数
                                                                                                                                                                                                                    • 7.3.1 派生类的构造函数
                                                                                                                                                                                                                      • 7.3.2 派生类的析构函数
                                                                                                                                                                                                                      • 7.4 多继承与虚基类
                                                                                                                                                                                                                        • 7.4.1 多继承中的二义性问题
                                                                                                                                                                                                                          • 7.4.2 虚基类的定义
                                                                                                                                                                                                                            • 7.4.3 虚基类的构造函数
                                                                                                                                                                                                                            • *7.5 子类型关系
                                                                                                                                                                                                                              • 7.6 虚函数与多态性
                                                                                                                                                                                                                                • 7.6.1 多态性的概念
                                                                                                                                                                                                                                  • 7.6.2 虚函数
                                                                                                                                                                                                                                    • *7.6.3 虚析构函数
                                                                                                                                                                                                                                      • 7.6.4 纯虚函数与抽象类
                                                                                                                                                                                                                                      • 本章小结
                                                                                                                                                                                                                                        • 习题
                                                                                                                                                                                                                                        • 第8章 运算符重载
                                                                                                                                                                                                                                          • 8.1 运算符函数与运算符重载
                                                                                                                                                                                                                                            • 8.2 典型运算符的重载
                                                                                                                                                                                                                                              • 8.2.1 关于分数类fraction
                                                                                                                                                                                                                                                • 8.2.2 重载取负运算符“-”
                                                                                                                                                                                                                                                  • 8.2.3 重载加法运算符“+”
                                                                                                                                                                                                                                                    • 8.2.4 重载增量运算符“++”
                                                                                                                                                                                                                                                      • 8.2.5 重载类型转换符“long”
                                                                                                                                                                                                                                                        • 8.2.6 重载赋值运算符“=”
                                                                                                                                                                                                                                                          • 8.2.7 重载复合赋值运算符“+=”
                                                                                                                                                                                                                                                            • 8.2.8 重载关系运算符“>”
                                                                                                                                                                                                                                                              • 8.2.9 重载下标访问运算符“[]”
                                                                                                                                                                                                                                                                • 8.2.10 重载流运算符“>>”和“<<”
                                                                                                                                                                                                                                                                • *8.3 运算符重载应注意的几个问题
                                                                                                                                                                                                                                                                  • 本章小结
                                                                                                                                                                                                                                                                    • 习题
                                                                                                                                                                                                                                                                    • 第9章 模板
                                                                                                                                                                                                                                                                      • 9.1 函数模板
                                                                                                                                                                                                                                                                        • 9.2 类模板
                                                                                                                                                                                                                                                                          • 本章小结
                                                                                                                                                                                                                                                                            • 习题
                                                                                                                                                                                                                                                                            • 第10章 C++流
                                                                                                                                                                                                                                                                              • 10.1 C++流的概念
                                                                                                                                                                                                                                                                                • 10.1.1 C++流的体系结构
                                                                                                                                                                                                                                                                                  • 10.1.2 预定义流对象
                                                                                                                                                                                                                                                                                    • 10.1.3 提取运算符>>和插入运算符<<
                                                                                                                                                                                                                                                                                      • 10.1.4 有格式输入输出和无格式输入输出
                                                                                                                                                                                                                                                                                        • 10.1.5 操作符
                                                                                                                                                                                                                                                                                        • 10.2 输入输出的格式控制
                                                                                                                                                                                                                                                                                          • 10.2.1 默认的输入输出格式
                                                                                                                                                                                                                                                                                            • 10.2.2 格式标志与格式控制
                                                                                                                                                                                                                                                                                              • 10.2.3 输入输出宽度的控制
                                                                                                                                                                                                                                                                                                • 10.2.4 浮点数输出方式的控制
                                                                                                                                                                                                                                                                                                  • 10.2.5 输出精度的控制
                                                                                                                                                                                                                                                                                                    • 10.2.6 对齐方式的控制
                                                                                                                                                                                                                                                                                                      • 10.2.7 小数点处理方式的控制
                                                                                                                                                                                                                                                                                                        • 10.2.8 填充字符的控制
                                                                                                                                                                                                                                                                                                          • 10.2.9 插入换行符
                                                                                                                                                                                                                                                                                                            • 10.2.10 输入输出数制状态的控制
                                                                                                                                                                                                                                                                                                            • 10.3 文件流
                                                                                                                                                                                                                                                                                                              • 10.3.1 文件流的建立
                                                                                                                                                                                                                                                                                                                • 10.3.2 文件流的关闭
                                                                                                                                                                                                                                                                                                                  • 10.3.3 文件流状态的判别
                                                                                                                                                                                                                                                                                                                    • 10.3.4 文件流的定位
                                                                                                                                                                                                                                                                                                                      • 10.3.5 有格式输入输出
                                                                                                                                                                                                                                                                                                                        • *10.3.6 无格式输入输出
                                                                                                                                                                                                                                                                                                                        • 本章小结
                                                                                                                                                                                                                                                                                                                          • 习题
                                                                                                                                                                                                                                                                                                                          • 附录1 考试指导
                                                                                                                                                                                                                                                                                                                            • 附录2 使用Visual C++ 2010学习版编写标准C++程序
                                                                                                                                                                                                                                                                                                                              • 附录3 C/C++常用标准库函数
                                                                                                                                                                                                                                                                                                                                • 附录4 ASCII码表
                                                                                                                                                                                                                                                                                                                                  • 附录5 全国计算机等级考试二级C++语言程序设计考试大纲
                                                                                                                                                                                                                                                                                                                                    • 附录6 全国计算机等级考试二级C++语言程序设计样题及参考答案
                                                                                                                                                                                                                                                                                                                                      • 附录7 习题参考答案

                                                                                                                                                                                                                                                                                                                                      相关图书