南开《程序设计基础（上）》课程期末复习资料

添加微信apfd6688查看答案,了解更多学习技巧,平 台作业、毕业论文完成时间友情提醒。。

一、客观部分：（单项选择、多项选择、不定项选择、判断）
（一）、选择部分
1、（  B  ）是一种利用计算机解决问题的思维方式，而不是具体的学科知识。
A. 逻辑思维
B. 计算思维
C. 实证思维
D. 伦理思维
★考核知识点: 计算思维
参见讲稿章节：1-1
附1.1.1（考核知识点解释）：
计算思维是运用计算机科学的基本理念，进行问题求解，系统设计以及理解人类行为。也就是说，计算思维是一种利用计算机解决问题的思维方式，而不是具体的学科知识。计算思维已成为世界公认的与理论思维、实验思维并列的三大思维之一。
2、（ D）常简称“流程图”，是人们对解决问题的方法、思路或算法的一种描述。
A. 逻辑图
B. 伪代码
C. 程序框图
D. 程序流程图
★考核知识点: 程序流程图
参见讲稿章节：1-1
附1.1.2（考核知识点解释）：
“程序流程图”常简称“流程图”，是人们对解决问题的方法、思路或算法的一种描述。流程图利用图形化的符号框来表示不同的操作，并用流程线来连接这些操作。通过画流程图，可以帮助我们清楚地描述算法，方便交流，并为后边编写程序实现算法打好基础。
流程图具有如下优点：
采用简单规范的符号，画法简单
结构清晰，逻辑性强
便于描述，容易理解
3、面对问题，需要找出解决问题的方法，我们把这种能够在有限的步骤内解决问题的过程和方法称为（  A  ）。
A. 算法
B. 程序
C. 程序设计
D. 编程
★考核知识点: 程序设计的基本概念
参见讲稿章节：1-2
附1.1.3（考核知识点解释）：
计算机程序是通过计算机程序语言精确描述算法的模型，它的作用是指示计算机进行必要的计算和数据处理从而解决特定的问题。计算机程序涉及两个基本概念——数据和算法。数据是程序使用和处理的信息。面对问题，需要找出解决问题的方法，我们把这种能够在有限的步骤内解决问题的过程和方法称为算法。
4、（  C  ）是指设计、编制、调试程序的方法和过程，是寻找算法并用计算机能够理解的语言表达出来的一种活动。
A. 算法
B. 程序
C. 程序设计
D. 编程
★考核知识点: 程序设计的基本概念
参见讲稿章节：1-2
附1.1.4（考核知识点解释）
用计算机求解问题的过程也称为程序设计过程，是指设计、编制、调试程序的方法和过程，是寻找算法并用计算机能够理解的语言表达出来的一种活动。程序设计过程涵盖了上述步骤，即明确要解决的问题，将问题抽象成一定的数学模型、找出解决问题的算法、用程序设计语言描述算法、运行程序求解问题。
5、人类使用计算机求解实际问题的基本步骤包括（ A B C D ）。
A. 将实际问题抽象成数学模型
B. 设计求解问题的算法
C. 编写程序实现算法
D. 运行程序求解问题
★考核知识点: 程序设计的基本概念
参见讲稿章节：1-2
附1.1.5（考核知识点解释）
人类使用计算机求解实际问题的基本步骤是：
（1）将实际问题抽象成数学模型
分析问题，从中抽象出处理的对象，用数据的形式对问题加以描述。
（2）设计求解问题的算法
对描述问题的数据设计出相应的处理方法，从而达到求解问题的目的。算法需要用某种形式（如自然语言、流程图、伪代码等）表示出来。确定算法是最关键的一步。
（3）编写程序实现算法
将算法翻译成计算机能够读懂的语言，期间还需要调试和测试计算机程序。
（4）运行程序求解问题
通过计算机运行程序，对描述问题的数据进行按照所设计的算法进行处理，最终得到问题的结果。
6、编写一个程序并让程序运行起来，一般包括编辑、（ C ）、连接和执行等步骤。
A. 改写
B. 设计
C. 编译
D. 录入
★考核知识点: 程序设计的基本概念
参见讲稿章节：1-2
附1.1.6（考核知识点解释）
编程是将所设计的算法转换成计算机能够运行的代码的过程。编写一个程序并让程序运行起来，一般包括编辑、编译、连接和执行等步骤。
7、针对（  A ）在进行大型项目设计时存在的缺陷，人们提出了面向对象程序设计（Object Oriented Programming, OOP）方法。
A. 结构化程序设计方法
B. 面向过程的程序设计方法
C. 理论化程序设计方法
D. 面向人类的程序设计方法
★考核知识点: 程序设计的基本概念
参见讲稿章节：1-2
附1.1.7（考核知识点解释）
20世纪60年代末期随着“软件危机”的出现，程序设计方法的研究开始受到重视。结构化程序设计方法（Structured Programming, SP）是程序设计历史中被最早提出的方法。70年代中后期，针对结构化程序设计在进行大型项目设计时存在的缺陷，又提出了面向对象程序设计（Object Oriented Programming, OOP）方法。近40年来面向对象程序设计方法的大量研究工作使得它成为目前最重要的程序设计方法。
SP结构化程序设计方法也称面向过程的程序设计方法，反映了过程性编程的方法。它根据执行的操作来设计一个程序，简单易学、容易掌握，模块的层次清晰，降低了程序设计的复杂性，程序的可读性强。SP方法便于多人分工开发和调试，从而有利于提高程序的可靠性。
OOP方法强调的是数据，而不是算法的过程性。根据人们认识世界的观念和方法，把任何事物都看成对象，复杂的对象是由简单的对象以某种方式组成，认为世界是由各种对象组成的。OOP方法中的对象是一个封装了数据和操作这些数据的代码的逻辑实体；类是具有相同类型的对象的抽象，一个对象所包含的所有数据和代码可以通过类来构造。OOP方法中的类通常规定了可以使用哪些数据和对这些数据执行哪些操作。数据表示对象的静态特征——属性，操作表示了对象的动态特性——行为。
8、（ A D ）等属于高级程序设计语言。
A. C++
B. 汇编
C. 机器语言
D. Python
★考核知识点: 程序设计语言
参见讲稿章节：1-3
附1.1.8（考核知识点解释）
计算机本身只会完成几十种或上百种不同的简单动作，每一个动作称为一条指令。计算机设计者为每一个动作用一个二进制的编码表示，并为每一个动作设计一种通用的格式，即设计由指令码和内存地址组成的指令。所有指令构成了计算机的指令系统。计算机唯一可以读懂的语言就是计算机的指令，叫做机器语言，它被称为低级程序设计语言。如果程序员直接把让计算机完成的任务以指令序列的形式写出来，就是机器语言程序设计。
高级程序设计语言，例如C、C++、Java、C#、Fortran、Python、R语言等，是为解决使用机器语言编写程序困难的问题而逐步发展起来的，其语法符合人的习惯，便于普通用户编程，但计算机却不懂。编译程序、编译系统或编译器就是能够把用高级语言写出的程序翻译为机器语言的指令序列的程序。
有了高级程序设计语言及其编译系统的帮助，人们可以编制出规模更大、结构更复杂的程序。
9、一个C++程序一般由（A B C D ）、输入/输出和注释等几部分组成。
A. 编译预处理命令
B. 函数
C. 语句
D. 变量
★考核知识点: C++程序
参见讲稿章节：1-4
附1.1.9（考核知识点解释）
一个C++程序一般由编译预处理命令、函数、语句、变量、输入/输出和注释等几部分组成。
10、C++程序的单行注释由（ D ）标识。
A. #
B. “”
C. $
D. //
★考核知识点: C++程序
参见讲稿章节：1-4
附1.1.10（考核知识点解释）
C++程序注释的作用就是帮助程序员阅读源程序，提高程序的可读性。编译器在进行编译时会忽略注释，即不会将注释的内容一起编译。注释有两种方式：
（1）单行注释。
使用符号“//”，其后面直到一行结束的内容都为注释内容。
（2）多行注释。
使用“/*”和“*/”，他们中间的内容为注释内容。
11、C++程序的编译预处理命令由（ B ）标识。
A. @
B. #
C. %
D. //
★考核知识点: C++程序
参见讲稿章节：1-4
附1.1.11（考核知识点解释）
C++的编译预处理命令包括：宏定义命令、文件包含命令和条件编译命令，都是以“#”开始。
12、一个C++程序一般由1个或（D）个函数组成。
A. 10
B. 20
C. 30
D. 多个
★考核知识点: C++程序
参见讲稿章节：1-4
附1.1.12（考核知识点解释）
C++程序中的“int main()”是程序的主函数。一个C++程序一般由一个或多个函数组成。这些函数可以是用户根据需要自己编写的函数——用户自定义函数，也可以是直接使用系统提供的函数——标准库函数。函数体用一对花括号“{”和“}”括起来。
13、一个C++程序如果要是进行标准的输入输出，需要使用（  A C ）。
A. cin
B. cread
C. cout
D. cwrite
★考核知识点: C++程序
参见讲稿章节：1-4
附1.1.13（考核知识点解释）
C++程序中的输入语句用来接受用户的输入，输出语句用来向用户返回程序的运行结果和相关信息。
（1）输出cout
“cout << "大家好！";”是输出语句，用cout（读C—Out）将用两端加上双引号表示的一个字符串“大家好！”输出到屏幕上。语句的中“<<”叫插入运算符，不能省略。 “cout << "结果为：" << result << endl;”的功能是先将字符串“结果为:”输出到屏幕上，然后再将变量result的值输出到屏幕上，最后在屏幕上输出一个换行。其中，endl是C++的一个控制符，表示重起一行。
（2）输入cin
 “cin >> x >> y;”是输入语句，用cin（读C—In）将用户通过键盘输入两个整数分别放在变量x和y中。语句的中“>>”叫提取运算符，也不能省略。语句“cin >> x >> y;”也可以用两条语句代替：
cin >> x;
cin >> y;
14、（  A B C ）是C++程序中允许的字符。
A. *
B. A
C. 0
D. ＠
★考核知识点: C++程序
参见讲稿章节：1-4
附1.1.14（考核知识点解释）
字符集是组成语言词法的一个字符**。程序员编写的源程序不能使用字符集以外的字符，否则编译系统无法识别。C++语言的字符集包括：
大写、小写英文字母，共52个。
数字字符0—9，共10个。
运算符、标点符号及其他字符，共30个。它们是：
            +  -  *  /  %  =   !   &  |  ~   ^  <   >
            ;  :  ?  ,   .   '   "   \
            (  )   [  ]   {  }   #   _    空格
15、（C）是C++程序中合法的用户自定义的标识符。
A. main
B. int
C. Main
D. 0_FAQ
★考核知识点: C++程序
参见讲稿章节：1-4
附1.1.15（考核知识点解释）
标识符是指由程序员定义的词法符号，用来给变量、函数、数组、类、对象、类型等命名。定义标识符应该遵守以下规则：
标识符只能使用大小写字母、数字和下划线（_）。
标识符的首字符必须是字母或下划线。
例如：
下列标识符是合法的：
        No200、m_name、v1_1、Prog1、name、warm、student
下列标识符是不合法的：
        100Student、%Num、Number5-3、AnShan Road 183、abc+123
C++标识符区分大写字母和小写字母。例如，Time、TIME、time等是3个不同的标识符。
C++对标识符的长度没有限制，但受编译系统的影响，C++标识符的长度最好不要超过32个字符。标识符不能与系统关键字（保留字）同名。
16、（ A ）包括编写和修改源代码的文本编辑器、编译器、连接器、程序调试和运行，以及其他程序开发的辅助功能和工具。
A. 集成开发环境
B. C++程序
C. Window操作系统
D. WORD
★考核知识点:集成开发环境
参见讲稿章节：1-5
附1.1.16（考核知识点解释）
集成开发环境（Integrated Development Environment, IDE）包括编写和修改源代码的文本编辑器、编译器、连接器、程序调试和运行，以及其他程序开发的辅助功能和工具。通过这个工具，可以大大地提高程序员开发程序的效率。
17、十进制数 14 对应的二进制数是（  B  ）。
A. 1111
B. 1110
C. 1010
D. 1101
★考核知识点:常用数制及不同数制数值之间的转换
参见讲稿章节：2-1
附1.1.17（考核知识点解释）
十进制数转换成非十进制数的方法是：整数部分的转换采用“除基取余法”；小数部分的转换采用“乘基取整法”。
【例】将十进制数20转换成二进制数。
解：采用“除基取余法”：

转换结果是：20=10100B。
18、十进制数 123 对应的二进制数是（  C  ）。
A. 1111000
B. 1111010
C. 1111011
D. 1111100
★考核知识点: 常用数制及不同数制数值之间的转换
参见讲稿章节：2-1
附1.1.18（考核知识点解释）
十进制数转换成非十进制数的方法是：整数部分的转换采用“除基取余法”；小数部分的转换采用“乘基取整法”。
【例2】将十进制数20转换成二进制数。
解：采用“除基取余法”：

转换结果是：20=10100B。
19、十六进制数ABH 变换为等值的十进制数是（  D  ）。
A. 17
B. 161
C. 21
D. 171
★考核知识点: 常用数制及不同数制数值之间的转换
参见讲稿章节：2-1
附1.1.19（考核知识点解释）
非十进制数转换成十进制数的方法是将非十进制数按权展开求和。
【例1】将二进制数 (1101.1)₂转换成十进制数。
解：(1101.1)₂ = 1×2³+1×2²+0×2¹+1×2⁰+1×2^–1
            = 8+4+0+1+0.5
            = 13.5
【例2】将八进制数(346)₈转换成十进制数。
解：(346)₈ = 3×8²+4×8¹+6×8⁰
         = 192+32+6
         = 230
【例3】将十六进制数(2A6.8)₁₆转换成十进制数。
解：(2A6.8)₁₆ = 2×16²+10×16¹+6×16⁰+8×16^–1
            = 512+160+6+0.5
            = 678.5
20、二进制数1001011 转换为等值的十进制数是（  C  ）。
A. 71
B. 73
C. 75
D. 77
★考核知识点: 常用数制及不同数制数值之间的转换
参见讲稿章节：2-1
附1.1.20（考核知识点解释）
非十进制数转换成十进制数的方法是将非十进制数按权展开求和。
【例1】将二进制数 (1101.1)₂转换成十进制数。
解：(1101.1)₂ = 1×2³+1×2²+0×2¹+1×2⁰+1×2^–1
            = 8+4+0+1+0.5
            = 13.5
【例2】将八进制数(346)₈转换成十进制数。
解：(346)₈ = 3×8²+4×8¹+6×8⁰
         = 192+32+6
         = 230
【例3】将十六进制数(2A6.8)₁₆转换成十进制数。
解：(2A6.8)₁₆ = 2×16²+10×16¹+6×16⁰+8×16^–1
            = 512+160+6+0.5
            = 678.5
21、二进制数1001101011 转换为等值的八进制数是（  B  ）。
A. 4651
B. 1153
C. 9AC
D. 26B
★考核知识点: 常用数制及不同数制数值之间的转换
参见讲稿章节：2-1
附1.1.21（考核知识点解释）
八进制数转换成二进制数的方法是：将每一位八进制数直接写成相应的3位二进制数。
二制数转换成八进制数的方法是：以小数点为界，向左或向右将每3位二进制数分成一组，如果不足3位，则用0补足。然后，将每一组二进制数直接写成相应的1位八进制数。
【例1】将八进制数(425.67)₈转换成二进制数。
解：(425.67)₈ = (100 010 101.110 111)₂
【例2】将二进制数(10101111.01101) ₂转换成八进制数。
解：(10101111.01101)₂ = (010 101 111.011 010)₂
                        = (257.32)₈
22、八进制数424.57转换为等值的二进制数是（  A ）。
A. 100010100.101111
B. 100011100.101111
C. 100100100.101011
D. 100100100.101101
★考核知识点: 常用数制及不同数制数值之间的转换
参见讲稿章节：2-1
附1.1.22（考核知识点解释）
八进制数转换成二进制数的方法是：将每一位八进制数直接写成相应的3位二进制数。
二制数转换成八进制数的方法是：以小数点为界，向左或向右将每3位二进制数分成一组，如果不足3位，则用0补足。然后，将每一组二进制数直接写成相应的1位八进制数。
【例1】将八进制数(425.67)₈转换成二进制数。
解：(425.67)₈ = (100 010 101.110 111)₂
【例2】将二进制数(10101111.01101) ₂转换成八进制数。
解：(10101111.01101)₂ = (010 101 111.011 010)₂
                        = (257.32)₈
23、十六进制数42B.5A转换为等值的二进制数是（  D ）。
A. 0100101011.01011010
B. 010000101011.0111010
C. 01000101011.01011010
D. 010000101011.01011010
★考核知识点: 常用数制及不同数制数值之间的转换
参见讲稿章节：2-1
附1.1.23（考核知识点解释）
十六进制数转换成二进制数的方法是：将每一位十六进制数直接写成相应的4位二进制数。
二进制数转换成十六进制数的方法是：以小数点为界，向左或向右将每4位二进制数分成一组，如果不足4位，则用0补足。然后，将每一组二进制数直接写成相应的1位十六进制数。
【例1】将十六进制数(2C8)₁₆转换成二进制数。
解：(2C8) ₁₆ = (0010 1100 1000) ₂
            = (1011001000) ₂
【例2】将二进制数(1011001.11)2转换成十六进制数。
解：(1011001.11)₂ =(0101 1001.1100)₂
                     =(59.C) ₁₆
24、二进制数01000101011.01011010转换为等值的十六数是（ B  ）。
A. 453.5A
B. 22B.5A
C. 42B.5B
D. 22B.262
★考核知识点: 常用数制及不同数制数值之间的转换
参见讲稿章节：2-1
附1.1.24（考核知识点解释）
十六进制数转换成二进制数的方法是：将每一位十六进制数直接写成相应的4位二进制数。
二进制数转换成十六进制数的方法是：以小数点为界，向左或向右将每4位二进制数分成一组，如果不足4位，则用0补足。然后，将每一组二进制数直接写成相应的1位十六进制数。
【例1】将十六进制数(2C8)₁₆转换成二进制数。
解：(2C8) ₁₆ = (0010 1100 1000) ₂
            = (1011001000) ₂
【例2】将二进制数(1011001.11)2转换成十六进制数。
解：(1011001.11)₂ =(0101 1001.1100)₂
                     =(59.C) ₁₆
25、下列无符号数中最大的是（  B   ）。
A. 101
B. (66)16
C. (145)8
D. (01100101)2
★考核知识点: 整数在计算机中的表示
参见讲稿章节：2-2
附1.1.25（考核知识点解释）
无符号整数的编码与其数值相同。因此，无符号整数只能表示正整数或0。
【例2】假设二进制数“01001010”表示的是一个无符号整数，则该无符号整数的值是多少？
解：01001011(二进制数)
    =0×2⁷+1×2⁶+0×2⁵+0×2⁴+1×2³+0×2²+1×2¹+1×2⁰
                        =0+64+0+0+8+0+2+1
                        =75
所以，二进制数“01001011”所代表的无符号整数的值是75。
8位二进制数表示的最大无符号整数是“11111111”，即2⁸-1，表示的最小无符号整数是“00000000”，即0。在计算机中，用于存储数据的位数越多，所能表示的数值的范围越大。
26、十进制数–100的8位二进制补码是（  A   ）。
A. 10011100
B. 11100100
C. 00011011
D. 10011011
★考核知识点: 整数在计算机中的表示
参见讲稿章节：2-2
附1.1.26（考核知识点解释）
在计算机中，将负数加模就可以转化成正数，使正数加负数转化成正数加正数。把补数用到计算机对数据的处理上，就是补码。在计算机系统中，正数的补码就是它本身，符号位取0，即和原码相同，负数的补码是该负数加模的结果。
补码的求法：

• 对正数，补码与原码相同。
• 对负数，由上面的规则求补码，需做减法，不方便。经推导可知，负数的补码等于其原码除符号位外按位“求反”(1变0，0变1)，末位再加1。

【例】求-75用一个字节表示的补码。
解：
1个字节是8个二进制位。由于75的值为1001011，所以，-75的原码为11001011，下面求-75的补码：
①对后7位数值位1001011逐位取返，即0变1，1变0。
原    值：1001011
逐位取返：0110100
②在末位加1。
        0110100
       +0000001
        0110101
用1个字节表示-75的补码为：
10110101
27、一个浮点法表示的数值由（ B D ）两部分组成。
A. 基数
B. 阶码
C. 指数
D. 尾数
★考核知识点: 实数在计算机中的表示
参见讲稿章节：2-3
附1.1.27（考核知识点解释）
在计算机领域，一般采用浮点数的形式来近似地表示实数。具体的说，在计算机中，表示一个实数的浮点数a是一个整数M乘以2的整数次幂E构成：

其中：s为数值的符号，称为数符，M为数值的精度，称为尾数，指数E称为阶码。
28、把一个汉字表示为两个字节的二进制码，这种编码称为（  B  ）码。
A. 五笔字型
B. 机内
C. 拼音
D. ASCII
★考核知识点: 非数值数据在计算机中的表示
参见讲稿章节：2-4
附1.1.28（考核知识点解释）
计算机中汉字的表示也是必须采用二进制编码。根据应用目的的不同，汉字编码分为外码、交换码、机内码和字形码。
（1）输入码
输入码属于外码，是用来将汉字输入到计算机中的一组键盘符号。目前常用的输入码有拼音码、五笔字型码、自然码、表形码、认知码、区位码和电报码等，一种好的编码应有编码规则简单、易学好记、操作方便、重码率低、输入速度快等优点，每个人可根据自己的需要进行选择。
（2）国际码
汉字交换码是指不同的具有汉字处理功能的计算机系统之间在交换汉字信息时所使用的代码标准。
中国标准总局1981年制定了中华人民共和国国家标准GB2312--80《信息交换用汉字编码字符集--基本集》，即国标码。该标准共收集常用汉字和符号7445个，其中一级汉字3755个，按拼音排序；二级汉字3008个，按部首排序；还有图形符号682个。
国际码使用两个字节来表示一个汉字或图形符号，每个字节与ASCII码一样，只是用低7位，即第8位为0。
例如，“啊”的编码为3021H。
由于汉字处理系统要和英文处理系统兼容，当ASCII和国际码同时出现在系统中时，会产生二义性：
例如，编码为3021H可以理解为中文“啊”，也可易理解为字符“0”和字符“!”的两个字符。
因此，汉字编码需要经过适当的变换后，才能存储在计算机中。这就是汉字的机内码或内码。
（3）机内码
常用的汉字机内码是在汉字国际标码加上8080H，即使每一个字节的第8位都变成1。由于ASCII码的最高位是0，这样就不会再产生二义性了。
例如，“啊”的机内码为国际码+8080H：
        0011 0000  0010 0001=3021H
     + 1000 0000  1000 0000=8080H
        1011 0000  1010 0001=B0A1H
每一个汉字和常用字符图形在计算机内部都用汉字机内码存储，在磁盘上记录它们也使用机内码。
（4）字形码
汉字字型码又称汉字字模，用于在显示屏或打印机输出汉字。汉字字型码通常有两种表示方式：点阵和矢量表示方法。
29、字符的ASCII码的表示方法是：使用8位二进制码并且（  C   ）。
A. 最低位为0
B. 最低位为1
C. 最高位为0
D. 最高位为1
★考核知识点: 非数值数据在计算机中的表示
参见讲稿章节：2-4
附1.1.29（考核知识点解释）
字符型数据也是人们常用的基本数据。主要包括计算机键盘上的英文字符、数字字符、各种标点符号等文本符号。当我们在键盘上敲入一个文本符号时，每一个符号都会以一个二进制的形式存储在计算机中。为了在一台计算机上存储的字符也能够在另一台计算机上正常显示，就需要给这些字符进行统一编码。在世界范围内通用的字符编码标准是ASCII（American Standard Code for Information Interchange）码。ASCII码使用1个字节，最高位为0，使用00000000～01111111为常用的128个字符编码。
30、在计算机中，用（ B ）来表示“逻辑真”。
A.  0
B.  1
C.  00
D.  11
★考核知识点: 非数值数据在计算机中的表示
参见讲稿章节：2-4
附1.1.30（考核知识点解释）
逻辑型数据只有“逻辑真”和“逻辑假”两个值，在计算机中只存储0和1两个数码的特点，很容易表示逻辑数据。即用1来表示“逻辑真”，用0来表示“逻辑假”。因此，不需要为逻辑型数据进行特殊的编码。
31、C++中的一个单精度浮点型数据占用的（ C  ）个字节。
A.  1
B.  2
C.  4
D.  8
★考核知识点: C++中的基本数据类型和转义字符
参见讲稿章节：2-5
附1.1.31（考核知识点解释）
C++中常用的基本数据类型及其取值范围

 
32、反斜杠在C++代码表示为（ B ）。
A.  \
B.  \\
C.  ”\”
D.  “\\”
★考核知识点: C++中的基本数据类型和转义字符
参见讲稿章节：2-5
附1.1.32（考核知识点解释）
C++的转义字符

 
33、C++中，常量99.78默认的数据类型是（  D  ）。
A.  char
B.  int
C.  float
D.  double
★考核知识点: 变量和常量
参见讲稿章节：2-6
附1.1.33（考核知识点解释）
C++中默认的浮点型常量的数据类型是double型，float型常量以字母F或f结尾。
34、下面定义变量语句中，错误的是（ B ）。
A.  int x(10), y(10);
B.  int x=y=10;
C.  int x=10, y=10;
D.  int x=10, y=x;
★考核知识点: 变量和常量
参见讲稿章节：2-6
附1.1.34（考核知识点解释）
（1）变量的定义
变量必须“先定义，后使用”。C++中定义变量的语法格式为：
    <类型名或类型定义>  <变量1>[, <变量2>, …, <变量n> ];
例如：
        int  length;
        double  length,  width,  height;
        char  c1, c2, c3;
        long  i, j, k;
（2）变量的初始化
在定义变量的同时可以为其赋一个初值，称为变量初始化。在C++中，变量初始化有两种形式，使用赋值运算符或使用圆括号。
例如：
    int num=100;        // 定义整型变量num，初值为100
    char c1='0' ;         // 定义字符型变量c1，初值为字符0
    double x(165.543);   // 定义双精度浮点型变量x，且初值为165.543
    int i, j, total(0);       // 定义整型变量i、j、total，且变量total的初值为0
35、在C++中，要求操作数必须是整型的运算符是（ D ）。
A.  +
B.  *
C.  /
D.  %
★考核知识点: 基本数据的处理
参见讲稿章节：2-7
附1.1.35（考核知识点解释）
求余运算要求两个操作数都必须是整型。例如，10%3的余数是1，-10%3的余数是-1。
36、表达式的100+43.6*'a'数据类型是（  D  ）。
A.  char
B.  int
C.  float
D.  double
★考核知识点: 基本数据的处理
参见讲稿章节：2-7
附1.1.36（考核知识点解释）
当一个表达式中出现两种不同的算数类型时，C++隐式转换是将级别低的数据类型自动转换成级别高的数据类型（即“向高看齐”），或将占用字节数少的类型转换成占用字节数多的数据类型。
数据类型的转换规则如下：

1. 如果有一个操作数的类型是long double，则将另一个操作数转换为long double；
2. 否则，如果有一个操作数的类型是double，则将另一个操作数转换为double；
3. 否则，如果有一个操作数的类型是float，则将另一个操作数转换为float；
4. 否则，此时操作数都是整型，C++将bool、char、unsigned char、signed char和short的值转换为int，其中，true被转换成1，false被转换成0。
5. 如果有一个操作数的类型是unsigned long，则将另一个操作数转换为unsigned long；
6. 否则，如果有一个操作数的类型是long int，另一个操作数是unsigned int，此时转换取决于两种类型的相对长度，如果long能够表示unsigned int的所有可能值，将unsigned int转换为long；否则，将两个操作数转换为unsigned long。
7. 否则，如果有一个操作数的类型是long，则将另一个操作数转换为long；
8. 否则，如果有一个操作数的类型是unsigned int，则将另一个操作数转换为unsigned int；
9. 此时，两个操作数都是int。

37、设i，j，k都是变量，下面不正确的赋值表达式是（  A  ）。
A.  i+j=k
B.  i=j=k
C.  i=j==k
D.  i++
★考核知识点: 基本数据的处理
参见讲稿章节：2-7
附1.1.37（考核知识点解释）
赋值运算符的左操作数必须是一个变量，对应一个内存空间。
38、运算符优先级按由高到低顺序排列正确的是（  C  ）。
A.  =，||，!=，%
B.  =，%，||，!=
C.  %，!=，||，=
D.  ||，!=，%，=
★考核知识点: 更多关于C++的运算符和表达式
参见讲稿章节：2-11
附1.1.38（考核知识点解释）
教材《程序设计基础》p46 表2-11 运算符及其优先级和结合性。
39、C++规定，else与（  D  ）相匹配。
A.  同一列的if
B.  同一行上的if
C.  之后最近的if
D.  之前最近的if
★考核知识点: 双路选择算法及其C++实现
参见讲稿章节：3-2
附1.1.39（考核知识点解释）
C++规定，else与之前最近的if相匹配。
40、以下不正确的if语句形式是（  B  ）。
A.  if(x>y);
B.  if(x=0)x+=y;
C.  if(X!＝y)cin>>x
D.  if(x＜y)
                   cout<<x；
else
cout>>y;
★考核知识点: 双路选择算法及其C++实现
参见讲稿章节：3-2
附1.1.40（考核知识点解释）
if…else语句中的(<测试条件>)不能缺少，<测试条件>可以是任意类型的表达式。但应该是有意义的表达式。本题B选项中的测试条件永远为假，因此词条if语句中的x+=y永远不会执行。
41、下面关于循环语句的叙述中，正确的是（  D  ）。
A.  for循环只能用于循环次数已知的情况
B.  for循环与while循环一样，都是先执行循环体后判断条件
C.  for循环体内不能出现while语句
D.  无论哪种循环，都可以从循环体内转移到循环体外
★考核知识点: 迭代算法及其C++实现
参见讲稿章节：3-5,3.6,3.7
附1.1.41（考核知识点解释）
for循环可以用于循环次数未知的情况。for循环与while循环不一样，是先执行语句1，再执行判断。for循环和while循环可以互相嵌套。无论哪种循环，都可以从循环体内转移到循环体外。
42、下面关于for循环的正确描述是（  A  ）。
A.  for循环的循环体语句中，可以包含多条语句，但必须用花括号括起来
B.  for循环是先执行循环体语句，后判断表达式
C.  在for循环中，不能用break语句跳出循环体
D.  for循环只能用于循环次数已经确定的情况
★考核知识点: 迭代算法及其for语句实现
参见讲稿章节：3-5
附1.1.42（考核知识点解释）
for循环可以用于循环次数未知的情况。for循环与while循环不一样，是先执行语句1，再执行判断。for循环和while循环可以互相嵌套。无论哪种循环，都可以从循环体内转移到循环体外。
43、下面关于break语句的描述中，不正确的是（  A  ）。
A.  break语句用于if语句中将退出该if语句
B.  break语句用于循环体内将退出该循环
C.  break语句用于switch语句中将退出该switch语句
D.  break语句在一个循环体内可以多次出现
★考核知识点: C++中的转向语句
参见讲稿章节：3-9
附1.1.43（考核知识点解释）
C++提供的break语句也称跳出语句。它的语法格式是关键字break加分号，即：
    break;
break语句可用在switch语句或3种循环语句中。break语句的功能是：结束当前正在执行的循环（for、while、do…while）或多路分支（switch）程序结构，转而执行这些结构后面的语句。在switch语句中，break用来使流程跳出switch语句，继续执行switch后的语句。在循环语句中，如果break语句位于多重循环的内循环中，则只能跳出它所在的内层循环。
44、在访问数组中的某个元素时，不可以用（ A  ）指定待访问元素的下标。
A.  浮点型常量
B.  整型变量
C.  整型表达式
D.  整型常量
★考核知识点: 一维数据及其C++实现
参见讲稿章节：4-1
附1.1.44（考核知识点解释）
一个数组包含多个元素，访问一维数组中某个元素的形式为：
    <数组名>[<下标>]
方括号中的<下标>用来表明要访问元素的位置，可以是常量表达式、也可以是变量表达式，但必须是整数。
45、下面各选项中的数组定义方式，错误的是（ D  ）。
A.  int a[7];
B.  const int N=7;  float b[N];
C.  char c[]="abcdef";
D.  double d[N];
★考核知识点: 一维数据及其C++实现
参见讲稿章节：4-1
附1.1.45（考核知识点解释）
数组本质上是一组变量，即数组的每一个元素都是一个变量。与前面学习过的简单变量一样，在使用数组之前，必须先给出数组的定义。一维数组的定义形式为：
    <数据类型> <数组名>[<常量表达式>];
<数据类型>指定了数组中每一个元素的类型，既可以是我们前面学习的int、float等基本数据类型，也可以是后面将要学习的指针、结构体、类等数据类型；
<数组名>的命名规则与简单变量的命名规则相同；
方括号中的<常量表达式>用来指明该数组中元素的数量，即数组的长度，它必须是整型常量、整型符号常量或枚举常量
46、数组定义为 int a[2][3]={1,2,3,4,5,6}，可以使用（ B  ）访问值为3的数组元素。
A.  a[2]
B.  a[0][2]
C.  a[3]
D.  a[1][3]
★考核知识点: 二维数据及其C++实现
参见讲稿章节：4-2
附1.1.46（考核知识点解释）
访问二维数组中某个元素的形式为：
    <数组名>[<行下标>][<列下标>]
方括号中的<行下标>用来表明要访问元素所在行的编号，<列下标>用来表明要访问元素所在列的编号。
<行下标>和<列下标>可以是常量表达式、也可以是变量表达式，但必须是整数。对于行数为M、列数为N的二维数组，其<行下标>取值范围为0~M-1、<列下标>取值范围为0~N-1。
47、已知“char s[]="hello";”，则下面叙述中正确的是（  C  ）。
A.  数组s的长度为5
B.  元素s[2]的值为'e'
C.  使用“cin>>s;”可以将从键盘上键入的字符串保存在数组s中
D.  使用“int t[]=s;”可以定义数组t、并用s中各元素的值初始化t中的各元素★考核知识点: 字符串及其C++实现
参见讲稿章节：4-3
附1.1.47（考核知识点解释）
由于字符串是一个由多个字符构成的一维数据，因此可以使用C++提供的一维字符型数组存储字符串。例如，可以定义一个一维字符型数组来存储字符串“Hello world!”：
    char str[] = {'H', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd', '!', '\0'};
或
    char str[] = "Hello world!";
上面两种形式的语句完全等价，都表示定义了一个名为str的一维字符型数组，并将该数组中的13个char类型的元素分别初始化为'H'、'e'、'l'、'l'、'o'、空格、'w'、'o'、'r'、'l'、'd'、'!'、'\0'。
48、已知“char s[][10]={"Microsoft","Visual","C++"};”，则语句“cout<<s[1];”会在屏幕上输出（  C  ）。
A.  i
B.  c
C.  Visual
D.  C++
★考核知识点: 多字符串及其C++实现
参见讲稿章节：4-4
附1.1.48（考核知识点解释）
对于多个字符串，可以用C++的二维字符型数组来存储。一个二维数据可以看作是由多个一维数据构成，使用二维数组可以存储一个二维数据或多个一维数据(字符串):。例如：
char name[3][20]={"Zhangsan", "Lisi", "Wangwu"};
二维字符型数组name包含的三个一维数组name[0]、name[1]和name[2]用来分别存储三个字符串"Zhangsan"、 "Lisi"和"Wangwu"。
49、在C++中可以自定义定义（ A  ）数据类型来实现对多属性数据的处理。
A.  结构体
B.  对象
C.  类
D.  数组
★考核知识点: 多属性数据及其C++实现
参见讲稿章节：4-5
附1.1.49（考核知识点解释）
对于多属性数据的存储问题，C++提供了相应的结构体，用户可以根据待解决问题定义结构体类型，并使用结构体类型定义变量实现多属性数据的存储。
50、已知“enum Color{Red, Green, Blue}; Color co;”，则下列语句正确的是（ B  ）。
A.  co=0;
B.  co=Blue;
C.  co=Green+1;
D.  co++;
★考核知识点: C++中的枚举数据类型
参见讲稿章节：4-7
附1.1.50（考核知识点解释）
对于多属性数据的存储问题，C++提供了相应的结构体，用户可以根据待解决问题定义结构体类型，并使用结构体类型定义变量实现多属性数据的存储。
51、函数定义中，下列有关return语句的描述错误的是（ C  ）。
A.  函数定义中可以没有return语句
B.  函数定义中可以有多个return语句，但是只执行其中之一
C.  函数定义中，一个return语句可以返回多个值
D.  只要和函数类型一致，return后面可以是常量、变量和任一表达式
★考核知识点: 模块化及其C++实现
参见讲稿章节：5-1
附1.1.51（考核知识点解释）
对于有值函数，在函数体中，用转向语句“return <表达式>;”返回函数的值，<表达式>的类型要与声明的函数类型相一致。对于无值函数，在定义函数时，函数类型要声明为void类型，在函数体内不需要有return语句，如果有return语句，则其后的表达式为空（即“return;”），表示仅从函数返回。
52、有关函数的形参和实参的描述，错误的是（ D  ）。
A.  函数调用时传入的参数称为实参
B.  函数定义时给出的参数称为形参
C.  形参和实参可以同名
D.  在函数体中修改形参，则相应实参的值也会改变
★考核知识点: 模块化及其C++实现
参见讲稿章节：5-1
附1.1.52（考核知识点解释）
由于采用单向传值，因此在函数体中修改形参，相应实参的值不会改变。
53、下列有关内联函数的描述中，错误的是（ C ）。
A.  内联函数必须在定义处加上inline关键字，否则就是普通的函数
B.  内联函数必须是一个小函数，不能包含循环、switch等语句
C.  一个函数中如果包含循环、switch等语句，则将其定义为内联函数时编译器会报错
D.  在编译程序时，系统会直接将调用内联函数的地方用内联函数中的语句体做等价替换，从而省去运行程序时函数调用所额外消耗的时间
★考核知识点: 模块化及其C++实现
参见讲稿章节：5-1
附1.1.53（考核知识点解释）
一个函数中如果包含循环、switch等语句，则将其定义为内联函数时编译器不会报错，但也不会将其编译为内联函数。
54、下列函数原型中，正确的是（ C  ）。
A.  void fun(int a=10, int b, int c);
B.  void fun(int a=10, int b=5, int c);
C.  void fun(int a, int b=5, int c=8);
D.  void fun(int, int=5, int);
★考核知识点:默认形参值
参见讲稿章节：5-3
附1.1.54（考核知识点解释）
当调用函数时，系统按照从左至右的顺序将实参传递给形参，当指定的实参数量不够时，没有相应实参的形参采用其默认值。因此，默认形参值生明在右边。
55、下列叙述中，正确的是（ D ）。
A.  在一个函数的函数体中可以定义另一个函数，但不可以调用另一个函数
B.  在一个函数的函数体中可以调用其他函数，但不能调用自己
C.  在一个函数的函数体中既可以定义另一个函数，也可以调用另一个函数
D.  在一个函数的函数体中既可以调用其他函数，也可以调用自己
★考核知识点: 递归算法及其C++实现
参见讲稿章节：5-2
附1.1.55（考核知识点解释）
递归函数就是在函数体内直接或间接地调用自己。
56、已知fun()函数的函数原型为“void fun(int x, double y=3.5, char z='#');”，则下面的函数调用中，不合法的调用是（ B ）。
A.  f(1);
B.  f(0, , '#')
C.  f(3, 3.7, '*')
D.  f(2, 4.2);
★考核知识点:默认形参值
参见讲稿章节：5-3
附1.1.56（考核知识点解释）
当调用函数时，系统按照从左至右的顺序将实参传递给形参，当指定的实参数量不够时，没有相应实参的形参采用其默认值。
57、对于重载函数，程序在调用时根据（ A ）能够区分开到底要调用哪个函数。
A.  参数个数或参数类型
B.  函数名
C.  函数类型
D.  以上都可以
★考核知识点:函数重载
参见讲稿章节：5-4
附1.1.57（考核知识点解释）
对于重载函数，程序在调用时根据参数的个数和类型区分开到底要调用哪个函数。
58、下列有关编译预处理命令的描述中，错误的是（  B ）。
A.  编译预处理命令都是以“#”开头
B.  编译预处理命令“#define X 5+1”，会将程序中出现的X替换为6
C.  编译预处理命令在编译之前进行处理
D.  编译预处理命令可以放在程序的开头、中间或末尾
★考核知识点:编译预处理
参见讲稿章节：5-5
附1.1.58（考核知识点解释）
编译预处理命令“#define X 5+1”，会将程序中出现的X替换为5+1。
59、下列有关文件包含的描述中，错误的是（  C ）。
A.  #include后面指定包含的文件可以是系统的头文件
B.  #include后面指定包含的文件可以是自定义的头文件
C.  如果包含的头文件名用尖括号括起，则会先在当前工作目录下搜索头文件
D.  如果包含的头文件名用双引号括起，则会先在当前工作目录下搜索头文件
★考核知识点:多文件结构
参见讲稿章节：5-6
附1.1.59（考核知识点解释）
如果包含的头文件名用尖括号括起，则会先在项目设置的默认目录下搜索头文件。
60、变量的（  A ）是指变量的作用范围，即变量在哪些地方可以使用，描述的是变量的空间属性。
A.  作用域
B.  生存期
C.  数据类型
D.  占用的字节数
★考核知识点:变量和函数的作用域和生存期
参见讲稿章节：5-7
附1.1.60（考核知识点解释）
变量的作用域是指变量的作用范围，即变量在哪些地方可以使用，描述的是变量的空间属性。
61、已知“int *p[5];”，则p是（  A  ）。
A.  指针数组
B.  函数指针变量
C.  指向行的指针变量
D.  一级指针变量
★考核知识点:地址与C++中的指针
参见讲稿章节：6-2
附1.1.61（考核知识点解释）
指针是一种数据类型，所以也可以创建一个指针类型的数组。指针数组同样可以有不同的维数，这里只给出一维指针数组的定义形式：
    <数据类型> *<数组名>[<常量表达式>];
指针数组中的每个元素都是指向同一数据类型的指针变量，指针数组元素的访问方法与一般数组元素的访问方法完全一样。
62、已知“int a=5, b, *p=&a;”，则下列语句中正确的是（  B  ）。
A.  &b=a;
B.  b=*p;
C.  *p=&b;
D.  b=p;
★考核知识点:地址与C++中的指针
参见讲稿章节：6-2
附1.1.62（考核知识点解释）
一个指针指向有效的内存地址后，就可以通过该指针访问其所指向内存空间中的数据，访问形式为：
    *<指针表达式>
63、已知“int a[10], *p=a;”，则以下各选项中对数组元素a[2]访问错误的是（ D  ）。
A.  *(a+2)
B.  p[2]
C.  *(p+2)
D.  p+2
★考核知识点:指针与数组
参见讲稿章节：6-3
附1.1.63（考核知识点解释）
通过指针加整数的运算即可以计算出后面元素的首地址并通过“*<首地址>”的方式访问数组中后面的元素。*(p+2)也可以写成p[2]的形式。
64、已知“int a[]={1,2,3,4,5},*p=a;”则以下各选项中值为数组元素地址的是（ C ）。
A.  *(a+3)
B.  &(a+3)
C.  p+3
D. *(&a[3])
★考核知识点:指针与数组
参见讲稿章节：6-3
附1.1.64（考核知识点解释）
指针加整数仍是地址，地址前加*表示该地址对应的元素。
65、已知“char a[]="abcd”,*p=a+2;"，则语句“cout<<p;”会在屏幕上输出（ C ）。
A.  bcd
B.  c
C.  cd
D.  d
★考核知识点:指针与字符串
参见讲稿章节：6-4
附1.1.65（考核知识点解释）
cout<<字符型指针,会输出字符型指针指向的一个字符串。
66、已知“int *p=new int[5];”，若堆内存分配成功，则指针p所指向的内存空间大小为（ D ）字节。
A.  5
B.  10
C.  15
D.  20
★考核知识点:动态使用内存空间
参见讲稿章节：6-5
附1.1.66（考核知识点解释）
由于一个int型占4个字节，因此，动态申请有5个元素的int型数组占20个字节。
67、已知程序段：
 int a[3][4],*p[3]={a[0], a[1], a[2]},**pp=p,i,j;
 for (i=0; i<3; i++)
for (j=0; j<4; j++)
  a[i][j]=i+j;
则pp[1][2]的值是（ B ）。
A.  2
B.  3
C.  4
D.  5
★考核知识点:二级指针
参见讲稿章节：6-6
附1.1.67（考核知识点解释）
由于p[3]={a[0], a[1], a[2]},**pp=p，因此pp[1][2]就是a[1][2]
68、已知“int* a[3], b=fun(a);”，则fun()函数原型为（ D ）。
A.  void fun(int (*p)[3]);
B.  void fun(int **p);
C.  int fun(int (*p)[3]);
D.  int fun(int *p[]);
★考核知识点:指针与函数
参见讲稿章节：6-7
附1.1.68（考核知识点解释）
在C++中，定义指针类型的形参变量有两种写法：
    <数据类型> *<形参名>
或
    <数据类型> <形参名>[]
此题中，数据类型为int *
69、已知函数原型“int fun(int, int);”，要定义一函数指针变量p使得“p=fun;”成立，则函数指针变量p的定义语句为（ A ）。
A.  int (*p)(int, int);
B.  int *p(int, int);
C.  int *p[int, int];
D. 以上选项都不对
★考核知识点:指针与函数
参见讲稿章节：6-7
附1.1.69（考核知识点解释）
函数指针变量的定义形式为：
    <函数类型> (*<变量名>)(<形参类型表>);
<函数类型>与函数指针变量所指向函数的返回值类型一致
<形参类型表>说明了函数指针变量所指向函数的各形参的类型。
70、已知“int a=10, *p, *&rp=p; rp=&a;*p+=20;cout<<a;”，则输出为（ C ）。
A.  10
B.  20;
C.  30
D. 以上选项都不对
★考核知识点:引用与函数
参见讲稿章节：6-8
附1.1.69（考核知识点解释）
rp是指针变量p的引用，rp=&a则p也存了a的地址，因此*p+=20等价于a=a+20。
71、已知函数定义“void fun(int &a, int b) { b++; a++;}”，则执行“int x=2,y=3; fun(x,y);”后，变量x、y的值分别（ B ）。
A.  2,3
B.  3,3
C.  2,4
D.  3,4
★考核知识点:引用与函数
参见讲稿章节：6-8
由于形参int &a是引用调用，因此，函数体中，a++就是实参x++。而int b是传值调用，因此，函数体中b++与不会改变实参y的值。
（二）、判断部分
1、计算机程序是使用计算机程序语言精确描述的实现模型，它的作用是指示计算机进行必要的计算和数据处理从而帮助我们解决特定的问题。（ √ ）
★考核知识点:程序设计的基本概念
参见讲稿章节：1-2
附1.2.1（考核知识点解释）
计算机程序是使用计算机程序语言精确描述的实现模型，它的作用是指示计算机进行必要的计算和数据处理从而帮助我们解决特定的问题。
2、SP结构化程序设计方法也称面向过程的程序设计方法，反映了过程性编程的方法，它是根据执行的操作来设计一个程序。（ √ ）
★考核知识点:程序设计的基本概念
参见讲稿章节：1-2
附1.2.2（考核知识点解释）
20世纪60年代末期随着“软件危机”的出现，程序设计方法的研究开始受到重视。结构化程序设计方法（Structured Programming, SP）是程序设计历史中被最早提出的方法。70年代中后期，针对结构化程序设计在进行大型项目设计时存在的缺陷，又提出了面向对象程序设计（Object Oriented Programming, OOP）方法。近40年来面向对象程序设计方法的大量研究工作使得它成为目前最重要的程序设计方法。
SP结构化程序设计方法也称面向过程的程序设计方法，反映了过程性编程的方法。它根据执行的操作来设计一个程序，简单易学、容易掌握，模块的层次清晰，降低了程序设计的复杂性，程序的可读性强。SP方法便于多人分工开发和调试，从而有利于提高程序的可靠性。
3、一个C++程序一般由多个函数组成。这些函数只能是用户根据需要自己编写的函数——用户自定义函数。（ ╳ ）
★考核知识点:C++程序
参见讲稿章节：1-4
附1.2.3（考核知识点解释）
一个C++程序一般由多个函数组成。这些函数可以是用户根据需要自己编写的函数——用户自定义函数，也可以是直接使用系统提供的函数——标准库函数。
4、C++中的任何一条语句以分号“；”结束。（√）
★考核知识点:C++程序
参见讲稿章节：1-4
附1.2.4（考核知识点解释）
语句是函数的基本组成单元。任何一条语句以分号“；”结束。
5、C++程序需要将数据放在内存单元中，变量名就是内存单元中数据的标识符，通过变量名来存储和访问相应的数据。（√）
★考核知识点:C++程序
参见讲稿章节：1-4
附1.2.5（考核知识点解释）
C++程序需要将数据放在内存单元中，变量名就是内存单元中数据的标识符，通过变量名来存储和访问相应的数据。
6、“cout<<"大家好！";”是输出语句，语句的中“<<”叫提取运算符，不能省略。（╳）
★考核知识点:C++程序
参见讲稿章节：1-4
附1.2.6（考核知识点解释）
“cout << "大家好！";”是输出语句，用cout（读C—Out）将用两端加上双引号表示的一个字符串“大家好！”输出到屏幕上。语句的中“<<”叫插入运算符，不能省略。
7、C++中的命名空间是为了解决C++中的变量、函数的命名冲突的问题而设置的。（√）
★考核知识点:C++程序
参见讲稿章节：1-4
附1.2.7（考核知识点解释）
“using namespace std;”是using编译指令，表示使用命名空间std。命名空间是为了解决C++中的变量、函数、类等命名冲突的问题而设置的。解决的办法就是将相同名字定义在一个不同名字的命名空间中。就好像Tom有一本《哈利波特》，Jane也有一本《哈利波特》。如果要借阅《哈利波特》这本书，就要说明是Tom的还是Jane的。Tom和Jane就是两个命名空间。如果前面声明过是Tom的（using namespace Tom;），则再遇到《哈利波特》时，指的就是Tom的《哈利波特》。
8、关键字是组成编程语言词汇表的标识符，用户可以用他们标识其他实体。（╳）
★考核知识点:C++程序
参见讲稿章节：1-4
附1.2.8（考核知识点解释）
关键字又称保留字，是组成编程语言词汇表的标识符，用户不能再用他们标识其他实体。
9、“No 123”可以是合法的C++标识符。（╳）
★考核知识点:C++程序
参见讲稿章节：1-4
附1.2.9（考核知识点解释）
标识符是指由程序员定义的词法符号，用来给变量、函数、数组、类、对象、类型等命名。定义标识符应该遵守以下规则：
标识符只能使用大小写字母、数字和下划线（_）。
标识符的首字符必须是字母或下划线。
10、C++中的任何一个程序必须有且只能有一个主函数main。（√）
★考核知识点:C++程序
参见讲稿章节：1-4
附1.2.10（考核知识点解释）
C++程序程序都是从主函数main开始执行的。所以，任何一个程序必须有且只能有一个主函数main。
11、每一种数制中最小的数码都是0，而最大的数码比基数小1。（√）
★考核知识点:常用数制及不同数制数值之间的转换
参见讲稿章节：2-1
附1.2.11（考核知识点解释）
数制就是用一组固定的数码和一套统一的规则来表示数值的方法。例如我们最熟悉的十进制，使用固定的10个数码（0，1，2，3，4，5，6，7，8，9）并按照“逢十进一”的规则来表示数值；再如，在计算机中使用的二进制数，使用两个固定数码（0和1），计数规则为“逢二进一”。
在一种数制中所使用的数码的个数称为该数制的基数。可见十进制的基数为10；二进制的基数为2。每一种数制中最小的数码都是0，而最大的数码比基数小1。
12、十进制数转换成非十进制数的方法是：整数部分的转换采用“除基取余法”；小数部分的转换采用“乘基取整法”。（√）
★考核知识点:常用数制及不同数制数值之间的转换
参见讲稿章节：2-1
附1.2.12（考核知识点解释）
非十进制数转换成十进制数的方法是将非十进制数按权展开求和。
十进制数转换成非十进制数的方法是：整数部分的转换采用“除基取余法”；小数部分的转换采用“乘基取整法”。
八进制数转换成二进制数的方法是：将每一位八进制数直接写成相应的3位二进制数。
二制数转换成八进制数的方法是：以小数点为界，向左或向右将每3位二进制数分成一组，如果不足3位，则用0补足。然后，将每一组二进制数直接写成相应的1位八进制数。
十六进制数转换成二进制数的方法是：将每一位十六进制数直接写成相应的4位二进制数。
二进制数转换成十六进制数的方法是：以小数点为界，向左或向右将每4位二进制数分成一组，如果不足4位，则用0补足。然后，将每一组二进制数直接写成相应的1位十六进制数。
13、只有负数有补码而正数无补码。（╳）
★考核知识点:整数在计算机中的表示
参见讲稿章节：2-2
附1.2.13（考核知识点解释）
补码的求法：

• 对正数，补码与原码相同。
• 对负数，由上面的规则求补码，需做减法，不方便。经推导可知，负数的补码等于其原码除符号位外按位“求反”(1变0，0变1)，末位再加1。

14、[X]_补是一个正数还是一个负数，是根据[X]_补的符号位是“0” 还是“1”确定的。（√）
★考核知识点:整数在计算机中的表示
参见讲稿章节：2-2
附1.2.14（考核知识点解释）
由求补码的方法可以看出，对于补码，其符号位和原码的符号相同，也表示了真值的符号，即正数的符号位为0，负数的符号位为1。
15、计算机中的数据不能精确地表示每一个小数。（√）
★考核知识点:实数在计算机中的表示
参见讲稿章节：2-3
附1.2.15（考核知识点解释）
实数可以用来表示连续的量。在实际运用中，实数经常被近似成一个有限小数，即保留小数点后n位，n为正整数。
16、浮点数尾数的整数部分的1和小数部分会一起被存储。（╳）
★考核知识点:实数在计算机中的表示
参见讲稿章节：2-3
附1.2.16（考核知识点解释）
浮点数都采用二进制数的规格化格式。规格化浮点数的规定为：

• 尾数的最高有效位为1。
• 为了提高浮点数的表数精度，最高位不会被存储，只存储尾数的小数部分。

17、ASCII 码是一种字符编码，而汉字的各种输入方法也是一种字符编码。（√）
★考核知识点:非数值型数据在计算机中的表示
参见讲稿章节：2-4
附1.2.17（考核知识点解释）
字符型数据也是人们常用的基本数据。主要包括计算机键盘上的英文字符、数字字符、各种标点符号等文本符号。当我们在键盘上敲入一个文本符号时，每一个符号都会以一个二进制的形式存储在计算机中。为了在一台计算机上存储的字符也能够在另一台计算机上正常显示，就需要给这些字符进行统一编码。在世界范围内通用的字符编码标准是ASCII（American Standard Code for Information Interchange）码。
计算机中汉字的表示也是必须采用二进制编码。根据应用目的的不同，汉字编码分为外码、交换码、机内码和字形码。
18、计算机中用两个字节来存放一个汉字的编码。（√）
★考核知识点:非数值型数据在计算机中的表示
参见讲稿章节：2-4
附1.2.18（考核知识点解释）
国际码使用两个字节来表示一个汉字或图形符号，每个字节与ASCII码一样，只是用低7位，即第8位为0。
每一个汉字和常用字符图形在计算机内部都用汉字机内码存储，在磁盘上记录它们也使用机内码。
常用的汉字机内码是在汉字国际标码加上8080H，即使每一个字节的第8位都变成1。由于ASCII码的最高位是0，这样就不会再产生二义性了。
19、字符串是指一串字符，可以连续，也可以不连续。（╳）
★考核知识点:非数值型数据在计算机中的表示
参见讲稿章节：2-4
附1.2.19（考核知识点解释）
字符串是指一串连续的字符。
20、逻辑型数据也需要进行编码。（╳）
★考核知识点:非数值型数据在计算机中的表示
参见讲稿章节：2-4
附1.2.20（考核知识点解释）
逻辑型数据只有“逻辑真”和“逻辑假”两个值，在计算机中只存储0和1两个数码的特点，很容易表示逻辑数据。即用1来表示“逻辑真”，用0来表示“逻辑假”。因此，不需要为逻辑型数据进行特殊的编码。
21、C++语言已预先解决了整型、浮点型、字符型和逻辑型等基本数据在计算机中如何表示、占用多少存储空间以及可以进行的操作等问题，程序员可以直接使用这些基本数据类型的数据来描述和处理自己的问题。（√）
★考核知识点:C++中的基本数据类型和转义字符
参见讲稿章节：2-5
附1.2.21（考核知识点解释）
对于基本数据类型，如整型、浮点型、字符型和逻辑型等，C++语言已预先解决了这些基本数据在计算机中如何表示、占用多少存储空间以及可以进行的操作等问题，程序员只需要以变量或常量的形式，就可以直接使用这些基本数据类型的数据来描述和处理自己的问题。
22、C++中默认的整型常量的数据类型是long int型。（╳）
★考核知识点:变量和常量
参见讲稿章节：2-6
附1.2.22（考核知识点解释）
C++中默认的整型常量的数据类型是int型。
23、C++中的常量分为直接常量和符号常量。（√）
★考核知识点:变量和常量
参见讲稿章节：2-6
附1.2.23（考核知识点解释）
常量是在程序运行过程中保持不变的数据。根据书写形式，可将常量分为直接常量和符号常量。直接常量就是通常所说的常数，在表达式中直接以常数的形式给出。符号常量，也称const常量，是用来表示一个常量的标识符。定义const常量的语法格式为：
    const <类型> <常量名>=<表达式>
例如：
    const double PI=3.1415926
24、在C++中，用一对双引号将字符括起来表示字符常量。其中双引号只是字符与其他部分的分隔符，不是字符的一部分。（╳）
★考核知识点:变量和常量
参见讲稿章节：2-6
附1.2.24（考核知识点解释）
在C++中，用一对单引号将字符括起来表示字符常量。其中单引号只是字符与其他部分的分隔符，不是字符的一部分。例如：
        'a' 、'A' 、'*'、'1'、'0'
其中，'a'和'A'是不同的字符常量；'1'和'0'是字符1和字符0，而不是数值。
25、已知int m=1,n=2; 则m/n的值为0.5。（╳）
★考核知识点:基本数据的处理
参见讲稿章节：2-7
附1.2.25（考核知识点解释）
两个整数相除，商为整数，小数部分全部舍去，不进行四舍五入。例如，1/3的结果为0，5/3结果为1。
26、前缀和后缀运算符++，当它们出现在表达式中，表达式的值会有所不同。（√）
★考核知识点:基本数据的处理
参见讲稿章节：2-7
附1.2.26（考核知识点解释）
“++”和“--”运算符都有前缀和后缀两种形式，都是对变量自身加1或减1，但前缀和后缀运算符都是有副作用的运算符，当出现在表达式中，表达式的值会有所不同。请进一步参考教材《程序设计基础》p42-2.9.1。
27、赋值表达式具有计算和赋值双重功能。（√）
★考核知识点:基本数据的处理
参见讲稿章节：2-7
附1.2.27（考核知识点解释）
赋值表达式是先计算赋值运算符右边操作数的值，再将该值赋值给左边的操作符，因此具有计算和赋值双重功能。
28、用C++表示数学表达式“0<=x<=100 ”的形式是“0<=x<=100”。（ ╳）
★考核知识点:基本数据的处理
参见讲稿章节：2-7
附1.2.28（考核知识点解释）
用C++表示数学表达式“0<=x<=100 ”的形式是“0<=x && x<=100”。
29、C++的程序就是由若干条语句构成的，C++的语句分为：定义/声明语句、表达式语句、复合语句、空语句、输入/输出语句和程序流程控制语句等。（√）
★考核知识点:C++中的基本语句
参见讲稿章节：2-8
附1.2.29（考核知识点解释）
C++的程序就是由若干条语句构成的，C++的语句分为：定义/声明语句、表达式语句、复合语句、空语句、输入/输出语句和程序流程控制语句等。
30、复合语句在语法上是多条语句。（╳）
★考核知识点:C++中的基本语句
参见讲稿章节：2-8
附1.2.30（考核知识点解释）
复合语句也称为块语句或程序块，用一对花括号将两条或两条以上的语句括起来就构成了复合语句。复合语句在语法上是一条语句，可以出现在程序的任何地方，主要用于函数体、循环语句和选择语句。
31、C++规定的逗号表达式的求值顺序为，1）从左向右依次求每一个表达式的值；2）最后1个表达式的值就是整个逗号表达式的值。（√）
★考核知识点:几种特殊运算符
参见讲稿章节：2-9
附1.2.31（考核知识点解释）
C++中的逗号运算符的优先级为18，结合性是左结合性。C++可以通过使用逗号运算符将多个表达式连接在一起，用逗号运算符将多个表达式连接在一起的逗号表达式的形式为：
        <表达式1>, <表达式2>, …, <表达式n>
C++规定的逗号表达式的求值顺序为：
①依次求解表达式1，表达式2，…，表达式n的值；
②表达式n的值就是整个逗号表达式的值。
32、C++中只有单目和双目运算符（╳）
★考核知识点:几种特殊运算符
参见讲稿章节：2-9
附1.2.32（考核知识点解释）
C++中只有一个三目运算符，即条件运算符“? :”。条件运算符的优先级为15，结合性是右结合性。由条件运算符构成的表达式的形式为：
        <表达式1> ? <表达式2> : <表达式3>
C++规定的条件运算符的求值顺序为：
①先计算表达式1的值；
②如果表达式1的值为真或为非0，则计算表达式2的值，表达式2的值即是整个条件表达式的值；
③如果表达式1的值为假或为0，则计算表达式3的值，表达式3的值即是整个条件表达式的值。
条件表达式能保证表达式2和表达式3两者之中只有一个被求值。
33、C++运算符的优先级分为18个等级，优先级的数值越小，优先级越高。（√）
★考核知识点:更多关于C++的运算符和表达式
参见讲稿章节：2-10
附1.2.33（考核知识点解释）
参考教材《程序设计基础》p46表2-11运算符及其优先级和结合性。
34、对于“&&”和“||”运算符，他们的求值顺序是从左到右求值，如果逻辑表达式的值已经能够确定了，就不再继续进行下面的计算了，也就是常说的短路运算。（√）
★考核知识点:更多关于C++的运算符和表达式
参见讲稿章节：2-10
附1.2.34（考核知识点解释）
C++中对于“&&”和“||”运算符，他们的求值顺序是从左到右求值，如果逻辑表达式的值已经能够确定了，就不再继续进行下面的计算了，也就是常说的短路运算。
【例】已知a、b、c的值均为0，逻辑表达式(a+=1) && (b+=1) || (c+=2)的值是什么？逻辑表达式求值后，a、b、c的值分别是多少？
解：由于赋值运算“a+=1”和“b+=1”的结果都是真，所以两者的逻辑与“&&”也是真，此时已经能够确定整个逻辑表达式的值为真，就不需要再进行下面的“c+=2”和“||”运算了。所以，整个逻辑表达式的值为真，a, b, c的值依次为是1，1，0。
35、if语句中的(<测试条件>)不能缺少，<测试条件>只能是逻辑类型的表达式（╳）
★考核知识点:单路选择算法及其C++实现
参见讲稿章节：3-1
附1.2.35（考核知识点解释）
if语句中的(<测试条件>)不能缺少，<测试条件>只能是任意类型的表达式。
36、if语句的执行过程是：首先计算<测试条件>的值，如果其值为“true”（非0），表示满足某种条件，执行<分支语句>，否则，表示不满足某种条件，不执行<分支语句>而直接执行分支语句后下面的语句。（√）
★考核知识点:单路选择算法及其C++实现
参见讲稿章节：3-1
附1.2.36（考核知识点解释）
if语句的执行过程是：首先计算<测试条件>的值，如果其值为“true”（非0），表示满足某种条件，执行<分支语句>，否则，表示不满足某种条件，不执行<分支语句>而直接执行分支语句后下面的语句。
37、对于需要进行双路选择处理的问题，C++提供了相应的if…else语句，用户可以使用该语句编写程序，让计算机完成问题的求解。（√）
★考核知识点:双路选择算法及其C++实现
参见讲稿章节：3-2
附1.2.37（考核知识点解释）
对于需要进行双路选择处理的问题，C++提供了相应的if…else语句，用户可以使用该语句编写程序，让计算机完成问题的求解。
38、用C++提供的if或if…else语句，就能够解决嵌套选择的问题。（√）
★考核知识点:嵌套选择算法及其C++实现
参见讲稿章节：3-3
附1.2.38（考核知识点解释）
用C++提供的if或if…else语句，就能够解决嵌套选择的问题。
39、设计迭代算法，要先要确定需要重复的操作或操作**，然后确定需要进行多少次这样的循环。（√）
★考核知识点:迭代选择算法及其for语句实现
参见讲稿章节：3-5
附1.2.39（考核知识点解释）
设计迭代算法，要先要确定需要重复的操作或操作**，然后确定需要进行多少次这样的循环。
40、语句for(i=0;;i++)和for(;;)都表示一次也不循环。（╳）
★考核知识点:迭代选择算法及其for语句实现
参见讲稿章节：3-5
附1.2.40（考核知识点解释）
for语句中的表达式2可以缺省，表示循环条件永远为真。
41、while语句中的“测试条件”表达式和for语句中的表达式2都能缺省。（╳）
★考核知识点:迭代选择算法及其while语句实现
参见讲稿章节：3-6
附1.2.41（考核知识点解释）
while语句中的“测试条件”表达式不能缺省。
42、以下程序段的功能是计算10！
int n=1,i=1;
while(i<=10);
 n=n*i++;
cout<<n;
（╳）
★考核知识点:迭代选择算法及其while语句实现
参见讲稿章节：3-6
附1.2.42（考核知识点解释）
这个语法没有错误，是逻辑错误。“while(i<=10);”多了一个“;”,导致无法实现求10！的功能。
43、使用C++的循环语句，在循环体采用选择语句来实现嵌套和选择的迭代算法。（√）
★考核知识点:迭代与选择嵌套及其C++实现
参见讲稿章节：3-8
附1.2.43（考核知识点解释）
使用C++的循环语句，在循环体采用选择语句来实现嵌套和选择的迭代算法。
44、使用转向语句可以使程序简练，或减少循环次数，或跳过那些没有必要再去执行的语句，以提高程序执行效率。（√）
★考核知识点:C++中的转向语句
参见讲稿章节：3-9
附1.2.44（考核知识点解释）
使用转向语句可以使程序简练，或减少循环次数，或跳过那些没有必要再去执行的语句，以提高程序执行效率。
45、continue语句可以用在switch语句和3种循环语句中。（╳）
★考核知识点:C++中的转向语句
参见讲稿章节：3-9
附1.2.45（考核知识点解释）
continue语句的功能是根据某个判断条件结束本次循环，即跳过循环体中尚未执行的语句，接着进行下一次是否执行循环的判定。
46、如果不加限制地使用goto语句，则会导致程序流程的混乱，降低程序的可读性。（√）
★考核知识点:C++中的转向语句
参见讲稿章节：3-9
附1.2.46（考核知识点解释）
goto语句的功能是将程序无条件跳转到<标号>指定的语句处继续执行。如果不加限制地使用goto语句，则会导致程序流程的混乱，降低程序的可读性。
47、当函数的返回类型为void型时，不需要写<表达式>，也可以不写return语句。（√）
★考核知识点:C++中的转向语句
参见讲稿章节：3-9
附1.2.47（考核知识点解释）
C++中的return语句也称函数返回语句。它的语法格式为：
    return [<表达式>];
return语句的功能是停止当前函数，程序转去执行调用当前函数后面的语句。对于非void类型的函数，必须有return语句，其中<表达式>的类型要与函数返回值的类型一致；当函数的返回类型为void型时，不需要写<表达式>，也可以不写return语句。
48、已知“int a[3];”，则可以使用“a[2]=10;”将数组a中的第3个元素赋值为10。（√）
★考核知识点:一维数据及其C++ 实现
参见讲稿章节：4-1
附1.2.48（考核知识点解释）
C++中，访问数组时，下标从0 开始。所以，a[2]表示数组的第3个元素。
49、定义数组时，数组的数据类型必须是C++中基本数据类型（╳）
★考核知识点:一维数据及其C++ 实现
参见讲稿章节：4-1
附1.2.49（考核知识点解释）
C++中定义数组时，数组的数据类型可以是C++中基本数据类型，也可以是用户自定义的数据类型。
50、已知“int a[][3]={{1,2,3},{4,5,6}};”，则二维数组a的行长为2。（√）
★考核知识点:二维数据及其C++ 实现
参见讲稿章节：4-2
附1.2.50（考核知识点解释）
由于有6个元素，已给出了列数3，因此，行长为2。
51、在C++中，要对double型的二般数组进行访问，可以整体进行，例如：
double a[3][4];
cin>>a;（╳）
★考核知识点:二维数据及其C++ 实现
参见讲稿章节：4-2
附1.2.51（考核知识点解释）
在C++中，要对double、int、float等型的二般数组进行访问，只能逐个元素进行。
52、已知“char c[]="abc";”，则可以使用“c="def";”更改c的值。（╳）
★考核知识点:字符串及其C++实现
参见讲稿章节：4-3
附1.2.52（考核知识点解释）
对字符型数组赋值字符串，可以采用逐个元素赋值（末尾增加字符‘\0’）或使用strcpy进行，不能使用赋值语句进行赋值。
53、已知“char s[]="hello";”，则使用“cout<<s;”可以在屏幕上输出“hello”。（ √）
★考核知识点:字符串及其C++实现
参见讲稿章节：4-3
附1.2.53（考核知识点解释）
cout后面插入字符型数组名表示要把数组中存的字符串输出到屏幕上。
54、定义结构体类型时，结构体中的所有成员必须具有相同的数据类型。（╳）
★考核知识点 多属性数据及其C++实现
参见讲稿章节：4-4
附1.2.54（考核知识点解释）
结构体中的各成员可以具有不同的数据类型。
55、同其他类型的变量一样，在定义结构体变量的同时可以为结构体变量中的各个成员赋初值。（√）
★考核知识点 多属性数据及其C++实现
参见讲稿章节：4-4
附1.2.55（考核知识点解释）
同其他类型的变量一样，在定义结构体变量的同时可以为结构体变量中的各个成员赋初值。结构体变量的初始化形式为：
    <结构体类型> <结构体变量名> = {成员1初值, 成员2初值, …, 成员N初值};
56、只能用枚举常量为枚举变量赋值。（√）
★考核知识点 C++中的枚举数据类型
参见讲稿章节：4-7
附1.2.56（考核知识点解释）
57、在日常生活中完成一项较复杂的任务时，我们通常会将任务分解成若干个子任务，通过完成这些子任务逐步实现任务的整体目标。（√）
★考核知识点 模块化及其C++实现
参见讲稿章节：5-1
附1.2.57（考核知识点解释）
在日常生活中完成一项较复杂的任务时，我们通常会将任务分解成若干个子任务，通过完成这些子任务逐步实现任务的整体目标。这就是模块化的思想。
58、只有带返回值的函数调用才能作为操作数参与其他运算。（√）
★考核知识点 模块化及其C++实现
参见讲稿章节：5-1
附1.2.58（考核知识点解释）
无值函数因为没有值，不能参与其他运算。
59、调用函数时传入的实参个数可以多于形参个数。（╳）
★考核知识点 模块化及其C++实现
参见讲稿章节：5-1
附1.2.59（考核知识点解释）
调用函数时传入的实参个数要等于形参个数。带默认形参值时，传入的实参个数可以小于形参个数。
60、函数必须有形参，用来进行函数调用。（╳）
★考核知识点 模块化及其C++实现
参见讲稿章节：5-1
附1.2.60（考核知识点解释）
可以定义无参函数。
61、C++中的函数分为两类：一类是用户根据待求解问题的需要自己定义的函数；另一类是系统提供的标准函数，即库函数。（√）
★考核知识点 模块化及其C++实现
参见讲稿章节：5-1
附1.2.61（考核知识点解释）
C++中的函数分为两类：一类是用户根据待求解问题的需要自己定义的函数；另一类是系统提供的标准函数，即库函数。
62、一个函数如何调用其他函数，他就是递归函数。（╳）
★考核知识点 递归函数及其C++实现
参见讲稿章节：5-2
附1.2.62（考核知识点解释）
直接或间接调用自己的函数就是递归函数。
63、函数的默认形参值可以在两个位置指定：如果有函数声明，则应在函数声明处指定；否则，直接在函数定义中指定。（√）
★考核知识点 默认形参值
参见讲稿章节：5-3
附1.2.63（考核知识点解释）
函数的默认形参值可以在两个位置指定：如果有函数声明，则应在函数声明处指定；否则，直接在函数定义中指定。
64、宏定义分为无参宏定义和带参宏定义两种。（√）
★考核知识点 编译预处理
参见讲稿章节：5-5
附1.2.64（考核知识点解释）
宏定义分为无参宏定义和带参宏定义两种。
65、有参宏定义和条件编译结合使用可以解决头文件重复包含问题。（╳）
★考核知识点 多文件结构
参见讲稿章节：5-6
附1.2.65（考核知识点解释）
无参宏定义和条件编译结合使用可以解决头文件重复包含问题。
66、静态局部变量在定义时若没有初始化，则自动初始化为0。（√）
★考核知识点 变量和函数的作用域和生存期
参见讲稿章节：5-7
附1.2.66（考核知识点解释）
静态局部变量的作用域是定义它的函数，生存期是全程的，在定义时若没有初始化，则自动初始化为0。
67、使用全局变量非常方便，可以多使用它。（╳）
★考核知识点 变量和函数的作用域和生存期
参见讲稿章节：5-7
附1.2.67（考核知识点解释）
使用全局变量会降低函数之间的独立性，在编写程序时尽量减少全局变量的使用。
68、多文件结构的程序可以使程序结构清晰，便于管理和查找。（√）
★考核知识点多文件结构
参见讲稿章节：5-6
附1.2.68（考核知识点解释）
多文件结构的程序可以使程序结构清晰，便于管理和查找。因此，在编写大规模程序时，通常采用多文件结构。
69、在运行一个程序时，系统将分配给该程序一些内存空间，根据内存空间中存储的数据类型不同，可将其分为4个区域：代码区、全局数据区、堆区、栈区。（√）
★考核知识点 数据存储的基本原理
参见讲稿章节：6-1
附1.2.69（考核知识点解释）
在运行一个程序时，系统将分配给该程序一些内存空间，根据内存空间中存储的数据类型不同，可将其分为4个区域：代码区、全局数据区、堆区、栈区。
70、定义任何一个变量，系统都会为其分配一定大小的内存空间，访问变量实际上就是访问其所对应内存空间中的数据。（√）
★考核知识点 数据存储的基本原理
参见讲稿章节：6-1
附1.2.70（考核知识点解释）
定义任何一个变量，系统都会为其分配一定大小的内存空间，访问变量实际上就是访问其所对应内存空间中的数据。
71、指针只能是常量，不可以是变量。（╳）
★考核知识点 地址与C++中的指针
参见讲稿章节：6-2
附1.2.71（考核知识点解释）
指针可以是常量，也可以是变量。
72、指针可以是常量，也可以是变量。（√）
★考核知识点 地址与C++中的指针
参见讲稿章节：6-2
附1.2.72（考核知识点解释）
指针可以是常量，也可以是变量。
73、int *p1, p2;则表示定义了两个指针变量p1和p2。（╳）
★考核知识点 地址与C++中的指针
参见讲稿章节：6-2
附1.2.73（考核知识点解释）
p1是int型指针变量，p2是普通int型变量。
74、已知“char a[]={'a', 'b', 'c'}, *p=a+1;”，则执行“*p++;”后，a[2]的值为'd'。（╳）
★考核知识点 指针与数组
参见讲稿章节：6-3
附1.2.74（考核知识点解释）
a[1]变成了’c’，而a[2]仍然是’c’。
75、*(<指针表达式>+i)与<指针表达式>[i]等价。（√）
★考核知识点地址与C++中的指针
参见讲稿章节：6-2
附1.2.75（考核知识点解释）
*(<指针表达式>+i)与<指针表达式>[i]等价。
76、已知“char str[]="my";”，则执行“strcat(str, "book");”后，str中保存的字符串为"mybook"。（╳）
★考核知识点 指针与字符串
参见讲稿章节：6-4
附1.2.76（考核知识点解释）
str[]只有3个字节，无法进行“strcat(str, "book");”工作，报错。
77、用new动态分配的内存必须用delete释放，否则会产生内存泄漏。（√）
★考核知识点 动态使用内存空间
参见讲稿章节：6-5
附1.2.77（考核知识点解释）
用new动态分配的内存必须用delete释放，否则会产生内存泄漏。
78、用new动态分配内存时既可以使用常量也可以使用变量指定元素数目。（√）
★考核知识点 动态使用内存空间
参见讲稿章节：6-5
附1.2.78（考核知识点解释）
与定义数组不同，用new动态分配内存时既可以使用常量也可以使用变量指定元素数目。
79、将数组名作为函数实参，表示将数组首地址传递给函数，在函数中可以通过该首地址操作数组中的元素并更改元素的值。（√）
★考核知识点 指针与函数
参见讲稿章节：6-7
附1.2.79（考核知识点解释）
将数组名作为函数实参，表示将数组首地址传递给函数，在函数中可以通过该首地址操作数组中的元素并更改元素的值。
80、函数返回的指针可以是全局变量、静态全局变量或静态局部变量的地址，也可以是局部变量的地址。（╳）
★考核知识点 指针与函数
参见讲稿章节：6-7
附1.2.80（考核知识点解释）
函数返回的指针可以是全局变量、静态全局变量或静态局部变量的地址，但不可以是局部变量的地址。
81、一个引用在初始化后，其所引用的对象可以改变。（╳）
★考核知识点 引用与函数
参见讲稿章节：6-8
附1.2.81（考核知识点解释）
一个引用在初始化后，其所引用的对象不可以改变。
82、只有返回引用的函数可以作为赋值语句的左值。（√）
★考核知识点 引用与函数
参见讲稿章节：6-8
附1.2.82（考核知识点解释）
只有返回引用的函数可以作为赋值语句的左值。
二、主观部分：
（一）、填空部分
1、现代人类必须掌握的三种思维包括：         、        和        。
★考核知识点：计算思维和程序流程图
参见讲稿章节：1-1
附2.1.1：（考核知识点解释）
要使用计算机解决问题，就要具备计算思维。周以真教授在《Computational Thinking》这篇论文中明确地定义了计算思维：计算思维是运用计算机科学的基本理念，进行问题求解，系统设计以及理解人类行为。也就是说，计算思维是一种利用计算机解决问题的思维方式，而不是具体的学科知识。计算思维已成为世界公认的与理论思维、实证思维并列的三大思维之一。
2、任何复杂的算法都可以由         、        和        这三种基本结构组成。
★考核知识点：计算思维和程序流程图
参见讲稿章节：1-1
附2.1.2：（考核知识点解释）
任何复杂的算法都可以由顺序结构、选择（分支）结构和循环（迭代）结构这三种基本结构组成，因此，只要规定好三种基本结构的流程图的画法，就可以画出任何算法的流程图。
3、程序流程图中的         表示处理，        表示判断。
★考核知识点：计算思维和程序流程图
参见讲稿章节：1-1
附2.1.3：（考核知识点解释）
流程图的基本符号和含义

符号名称	图形符号	含                  义
圆角矩形		开始框或结束框，描述算法的开始或结束
矩    形		处理框，描述处理
平行四边形		输入输出框，描述
菱    形		判断框，根据某个条件是否满足，进行进一步相应的处理。
流程线		流程线，面熟各种处理之间的顺序关系

 
4、         是一个软件，运行该软件将源代码翻译成计算机能够识别的内部语言——         。
★考核知识点：程序设计的基本概念
参见讲稿章节：1-2
附2.1.4：（考核知识点解释）
编译器是一个软件，运行该软件将源代码翻译成计算机能够识别的内部语言——机器语言。源文件经过编译后就会生成程序的目标代码文件，目标代码也称目标程序。
5、         、         、        等都是高级程序设计语言。
★考核知识点：高级程序设计语言
参见讲稿章节：1-3
附2.1.5：（考核知识点解释）
高级程序设计语言，例如C、C++、Java、C#、Fortran、Python、R语言等，是为解决使用机器语言编写程序困难的问题而逐步发展起来的，其语法符合人的习惯，便于普通用户编程，但计算机却不懂。
6、一个C++程序一般由         、         、        、         、         和        等几部分组成。
★考核知识点：C++程序
参见讲稿章节：1-4
附2.1.6：（考核知识点解释）
一个C++程序一般由编译预处理命令、函数、语句、变量、输入/输出和注释等几部分组成。
7、用C++源程序文件的扩展名为        ，一般放在项目的源文件目录中。
★考核知识点：集成开发环境
参见讲稿章节：1-5
附2.1.7：（考核知识点解释）
用C++源程序文件的扩展名为.cpp，一般放在项目的源文件目录中。该源文件不能直接在机器中运行，需要经过后面的编译连接成可执行文件后，才能运行。
8、开发一个软件，相当于开发一个        ，项目的作用是协调组织好一个软件中的所有程序代码、头文件或其他额外资源。。
★考核知识点：集成开发环境
参见讲稿章节：1-5
附2.1.8：（考核知识点解释）
开发一个软件，相当于开发一个项目，项目的作用是协调组织好一个软件中的所有程序代码、头文件或其他额外资源。
9、计算机领域中常用的数制有4种：即二进制、     、      和        。
★考核知识点：常用数制及不同数制数制之间的转换
参见讲稿章节：2-1
附2.1.9：（考核知识点解释）
计算机领域中常用的数制有4种：即二进制、八进制、十进制和十六进制。
10、十进制数转换成非十进制数的方法是：整数部分的转换采用         ；小数部分的转换采用         。
★考核知识点：常用数制及不同数制数制之间的转换
参见讲稿章节：2-1
附2.1.10：（考核知识点解释）
十进制数转换成非十进制数的方法是：整数部分的转换采用“除基取余法”；小数部分的转换采用“乘基取整法”。
11、64位计算机占         个Byte，占         个bit。
★考核知识点：整数在计算机中的表示
参见讲稿章节：2-2
附2.1.11：（考核知识点解释）

• 位（bit）

计算机中最小的数据单位是二进制的一个数位，简称位(bit)，译音为“比特”。一个二进制位可以表示0和1两种状态，即21种状态，所以，n个二进制位可以表示2n种状态。位数越多，所能表示的状态就越多，也就能够表示更多的数据或信息。

• 字节（Byte）

8位为一个字节(Byte)，译音为“拜特”，记作B。
字节是计算机中用来表示存储空间大小的最基本的容量单位。表示更多的存储容量经常使用KB（210B）、MB（220B）、GB（230B）和TB（240B）等单位。

• 字（word）

字（word）是计算机一次能够存储和处理的二进制位的长度。所谓的64位计算机，含义是该计算机的字长是64个二进制位，即每一个字由8个字节组成。
 
12、在计算机中用二进制数来表示整数，采用           和           两种形式。         只能表示正整数和0。         可以用来表示正整数、0和负整数。
★考核知识点：整数在计算机中的表示
参见讲稿章节：2-2
附2.1.12：（考核知识点解释）
在计算机中用二进制数来表示整数，采用无符号（称为无符号整数）和有符号（称为有符号整数）两种形式。无符号整数只能表示正整数和0。有符号整数可以用来表示正整数、0和负整数。
13、计算机中汉字的表示也是必须采用二进制编码。根据应用目的的不同，汉字编码分为           、           、         和         。
★考核知识点：非数值数据在计算机中的表示
参见讲稿章节：2-4
附2.1.13：（考核知识点解释）
计算机中汉字的表示也是必须采用二进制编码。根据应用目的的不同，汉字编码分为外码（输入码）、国际交换码、机内码和字形码。
14、在C++中，除了教材中的基本数据类型，还提供了           、           、
           和             等基本数据类型。
★考核知识点：C++中的基本数据类型和转义字符
参见讲稿章节：2-5
附2.1.14：（考核知识点解释）
在C++中，还提供了unsigned char、long、unsigned long和long double等基本数据类型。
15、在C++中，存储字符串常量采用的是向量法。为了能够识别字符串结束位置，C++系统会在字符串的末尾自动添加一个ASCII编码为        的字符（也称空字符或'\0'）作为字符串的结束符，所以每个字符串的存储长度总是比其实际长度（字符个数）          。
★考核知识点：常量和变量
参见讲稿章节：2-6
附2.1.15：（考核知识点解释）
在C++中，存储字符串常量采用的是向量法。为了能够识别字符串结束位置，C++系统会在字符串的末尾自动添加一个ASCII编码为00H的字符（也称空字符或'\0'）作为字符串的结束符，所以每个字符串的存储长度总是比其实际长度（字符个数）多1。
16、C++中的逻辑型也只有两个值：          和          ，他们分别表示“逻辑真”和“逻辑假”。
★考核知识点：常量和变量
参见讲稿章节：2-6
附2.1.16：（考核知识点解释）
C++中的逻辑型也只有两个值：true和false，他们分别表示“逻辑真”和“逻辑假”。
17、在C++中，字符串常量的表示方法是用一对        将字符串括起来。其中的双引号同样是分隔符，不是字符串的一部分。
★考核知识点：常量和变量
参见讲稿章节：2-6
附2.1.17：（考核知识点解释）
在C++中，字符串常量的表示方法是用一对双引号将字符串括起来。其中的双引号同样是分隔符，不是字符串的一部分。
18、在定义变量的同时可以为其赋一个初值，称为变量初始化。在C++中，变量初始化有两种形式，使用      或      。
★考核知识点：常量和变量
参见讲稿章节：2-6
附2.1.18：（考核知识点解释）
 
在定义变量的同时可以为其赋一个初值，称为变量初始化。在C++中，变量初始化有两种形式，使用赋值运算符或使用圆括号。
例如：
    int num=100;        // 定义整型变量num，初值为100
    char c1='0' ;         // 定义字符型变量c1，初值为字符0
    double x(165.543);   // 定义双精度浮点型变量x，且初值为165.543
    int i, j, total(0);       // 定义整型变量i、j、total，且变量total的初值为0
19、根据操作数的不同，可将运算符分为三类：       、       和       。
★考核知识点：基本数据的处理
参见讲稿章节：2-7
附2.1.19：（考核知识点解释）
运算符是编译器能够识别的具有运算含义的符号。
根据操作数的不同，可将运算符分为三类：单目运算符（一个操作数）、双目运算符（两个操作数）和三目运算符（三个操作数）。
20、表达式是由运算符将常量、变量、函数调用等连接在一起的式子。一个合法的C++表达式经过运算会有一个某种类型的值。使用不同的运算符可以构成不同类型的表达式，如：          、          和           、          等等。
★考核知识点：基本数据的处理
参见讲稿章节：2-7
附2.1.20：（考核知识点解释）
表达式是由运算符将常量、变量、函数调用等连接在一起的式子。一个合法的C++表达式经过运算会有一个某种类型的值。使用不同的运算符可以构成不同类型的表达式，如算术表达式、赋值表达式、关系表达式、逻辑表达式等等。
21、写出判断1个字符变量ch是否为英文字母字符的逻辑表达式。
                                         或                              。
★考核知识点：基本数据的处理
参见讲稿章节：2-7
附2.1.21：（考核知识点解释）
写出判断1个字符变量ch是否为英文字母字符的逻辑表达式。
可以用字符直接常量的形式判断该字符是否为英文字符：
    ch>='a' && ch<='z' || ch>='A' && ch<='Z'
也可以用字符变量ch的ASCII码判断该字符是否为英文字符：
    ch>=97 && ch<=122 || ch>=65 && ch<=90
22、若x的值为10，则表达式x%-3的值为            ，表达式x%3的值为            。
★考核知识点：基本数据的处理
参见讲稿章节：2-7
附2.1.22：（考核知识点解释）
若x的值为10，则表达式x%-3的值为1，表达式x%3的值为1，即取余运算结果的符号与被除数符号相同。
23、各种那个赋值运算符都是有副作用的运算符，他们所作用的对象必须是其值允许改变的变量，即赋值运算符的左操作数必须是一个存放数据的空间，这种变量也被称为      。
★考核知识点：基本数据的处理
参见讲稿章节：2-7
附2.1.23：（考核知识点解释）
各种那个赋值运算符都是有副作用的运算符，他们所作用的对象必须是其值允许改变的变量，即赋值运算符的左操作数必须是一个存放数据的空间，这种变量也被称为左值。
24、C++采取两种方法对数据类型进行转换：           和           。
★考核知识点：基本数据的处理
参见讲稿章节：2-7
附2.1.24：（考核知识点解释）
C++允许用户根据需要在丰富的基本数据类型中选择不同的类型，不同的基本数据类型的数据进行混合运算时，必须先转换成同一类型，然后再进行运算。C++采取两种方法对基本数据类型进行转换：隐式转换（也称自动转换）和显式转换（也称强制转换）。
25、C++的语句分为：           、           、           、           、输入/输出语句和程序流程控制语句等。
★考核知识点：C++中的基本语句
参见讲稿章节：2-8
附2.1.25：（考核知识点解释）
语句是C++程序中的基本功能单元。程序中的每一条语句都表示为完成某个任务而进行的某种处理动作。
C++的程序就是由若干条语句构成的，C++的语句分为：定义/声明语句、表达式语句、复合语句、空语句、输入/输出语句和程序流程控制语句等。
26、C++的定义和使用命名空间的关键字是           。
★考核知识点：C++中的基本语句
参见讲稿章节：2-8
附2.1.26：（考核知识点解释）
命名空间是ANSI C++引入的可以由用户命名的作用域，用来解决大型程序中标识符重名的问题。定义一个命名空间的语法格式为：
    namespace <命名空间名>
    {
        常量、变量、函数、类、对象等的声明或定义
    }
命名空间的声明语法格式是：
    using namespace <命名空间名>;
27、表达式x<0?-x:x的功能是           。
★考核知识点：C++中的几个特殊运算符
参见讲稿章节：2-9
附2.1.27：（考核知识点解释）
答案：求x的绝对值。
C++中只有一个三目运算符，即条件运算符“? :”。条件运算符的优先级为15，结合性是右结合性。由条件运算符构成的表达式的形式为：
        <表达式1> ? <表达式2> : <表达式3>
C++规定的条件运算符的求值顺序为：
①先计算表达式1的值；
②如果表达式1的值为真或为非0，则计算表达式2的值，表达式2的值即是整个条件表达式的值；
③如果表达式1的值为假或为0，则计算表达式3的值，表达式3的值即是整个条件表达式的值。
28、若x、y为double型，则表达式x=1,y=1,y+=++x+1/2的值是           ，x的值是           ，y的值是           。
★考核知识点：C++中的几个特殊运算符
参见讲稿章节：2-9
附2.1.28：（考核知识点解释）
答案：3,2,3
C++中的逗号运算符的优先级为18，结合性是左结合性。C++可以通过使用逗号运算符将多个表达式连接在一起，用逗号运算符将多个表达式连接在一起的逗号表达式的形式为：
        <表达式1>, <表达式2>, …, <表达式n>
C++规定的逗号表达式的求值顺序为：
①依次求解表达式1，表达式2，…，表达式n的值；
②表达式n的值就是整个逗号表达式的值。
29、sizeof（1）的值是           ，sizeof（float）的值是           ，sizeof(“南开大学”)的值是           。
★考核知识点：C++中的几个特殊运算符
参见讲稿章节：2-9
附2.1.29：（考核知识点解释）
答案：4,4,9
C++中的sizeof运算符是一个单目运算符，用于计算数据类型、变量或常量的长度占用内存的字节数。sizeof运算符的优先级为3级，结合性是右结合性。由sizeof运算符构成的表达式的形式为：
        sizeof(数据类型名或表达式)
例如：
        sizeof(int)是求int型的占用内存数，结果为4。
        int a；
        sizeof(a)求变量a占用的内存数，由于a是int型变量，所以结果为4。
        sizeof('a')是求字符常量'a'的长度，一个字符占用一个字节，所以结果为1。
    sizeof(34.65+10)是求表达式34.65+10的长度，由于该表达式是double型，所以结果为8。
    sizeof("xyz100")是求字符串常量"xyz100"的长度，由于字符串的结束标记'\0'还要占用一个字节，所以结果为7。
    sizeof("中华民族")是求字符串常量"中华民族"的长度，由于一个汉字的内码占两个字节，再加上字符串结束标记，'\0'，所以结果为9。
30、计算一个表达式的值一般需要引用一些变量。在表达式求值过程中，只提取这些变量的值，但不改变这些变量的值，这样的表达式称为           的表达式。一个表达式在求值过程中，对使用的变量不但提取变量的值，而且还对它们的值加以改变，这样的表达式           称为           的表达式。
★考核知识点：更多关于C++的运算符和表达式
参见讲稿章节：2-10
附2.1.30：（考核知识点解释）
计算一个表达式的值一般需要引用一些变量。在表达式求值过程中，只提取这些变量的值，但不改变这些变量的值，这样的表达式称为无副作用的表达式。一个表达式在求值过程中，对使用的变量不但提取变量的值，而且还对它们的值加以改变，这样的表达式称为有副作用的表达式。
31、处理过程中的一些步骤需要根据不同的情况进行不同的处理，这种情况就是           。
★考核知识点：单路选择算法及其C++实现
参见讲稿章节：3-1
附2.1.31：（考核知识点解释）
处理过程中的一些步骤需要根据不同的情况进行不同的处理，这种情况就是选择。
32、对于需要进行单路选择处理的问题，C++提供了相应的           语句，用户可以使用该语句编写程序，让计算机完成问题的求解。
★考核知识点：单路选择算法及其C++实现
参见讲稿章节：3-1
附2.1.32：（考核知识点解释）
对于需要进行单路选择处理的问题，C++提供了相应的if语句，用户可以使用该语句编写程序，让计算机完成问题的求解。
33、在一个选择算法中，选择处理的一路或两路还是一个选择算法，这就构成了选择           。
★考核知识点：嵌套选择及其C++实现
参见讲稿章节：3-3
附2.1.33：（考核知识点解释）
在一个选择算法中，选择处理的一路或两路还是一个选择算法，这就构成了选择的嵌套。
34、C++中专门的           语句用来实现多路选择算法实现。
★考核知识点：多路选择算法及其C++实现
参见讲稿章节：3-4
附2.1.34：（考核知识点解释）
使用if…else语句可以处理多选择问题，但会因为嵌套层次太多而导致程序的可读性下降，且容易出错。C++提供了适合处理多选择情况的switch语句。
35、C++中能实现迭代算法的语句包括           、              和 do while。
★考核知识点：嵌套选择及其C++实现
参见讲稿章节：3-5、3-6
附2.1.35：（考核知识点解释）
C++中能实现迭代算法的语句包括for语句、while语句和 do while。
36、switch语句中的<测试条件>表达式只能是           、           或枚举型的表达式。
★考核知识点：多路选择算法及其C++实现
参见讲稿章节：3-4
附2.1.36：（考核知识点解释）
switch语句中的<测试条件>表达式只能是整形、字符型或枚举型的表达式。
37、一维数据是指数据元素的值由           因素唯一确定。
★考核知识点：一维数据及其C++实现
参见讲稿章节：4-1
附2.1.37：（考核知识点解释）
一维数据是指数据元素的值由一个因素唯一确定。
38、对于长度为N的一维数组，其<下标>的取值范围为       ——         。
★考核知识点：一维数据及其C++实现
参见讲稿章节：4-1
附2.1.38：（考核知识点解释）
对于长度为N的一维数组，其<下标>的取值范围为0——N-1。
39、在定义二维数组的同时可以为数组中的各个元素赋初值，这就是二维数组的         。
★考核知识点：二维数据及其C++实现
参见讲稿章节：4-2
附2.1.39：（考核知识点解释）
在定义二维数组的同时可以为数组中的各个元素赋初值，这就是二维数组的初始化。
40、在C++中，字符串以         作为结束标识。在存储包含N个字符的字符串时，需要留出一个元素保存'\0'、使用长度至少为         的一维字符型数组。
★考核知识点：字符串其C++实现
参见讲稿章节：4-3
附2.1.40：（考核知识点解释）
在C++中，字符串以字符’\0’作为结束标识。在存储包含N个字符的字符串时，需要留出一个元素保存'\0'、使用长度至少为N+1的一维字符型数组。
41、定义结构体类型的关键字是         。
★考核知识点：多属性数据及其C++实现
参见讲稿章节：4-5
附2.1.41：（考核知识点解释）
定义结构体类型的关键字是struct。
42、结构体数组中的每一个元素都是结构体         。
★考核知识点：一组多属性数据的处理
参见讲稿章节：4-6
附2.1.42：（考核知识点解释）
结构体数组中的每一个元素都是结构体变量。
42、只能用枚举         为枚举变量赋值。
★考核知识点：一组多属性数据的处理
参见讲稿章节：4-6
附2.1.42：（考核知识点解释）
只能用枚举常量为枚举变量赋值。
43、         是指解决一个复杂问题时将其自顶向下逐层划分为若干子问题的过程。每个子问题就是一个模块。
★考核知识点：模块化及其C++实现
参见讲稿章节：5-1
附2.1.43：（考核知识点解释）
模块化是指解决一个复杂问题时将其自顶向下逐层划分为若干子问题的过程。每个子问题就是一个模块。
44、         是一个能够完成某个独立功能的程序模块（子程序）。
★考核知识点：模块化及其C++实现
参见讲稿章节：5-1
附2.1.44：（考核知识点解释）
函数是一个能够完成某个独立功能的程序模块（子程序）
45、函数和外界的接口体现为         传递和函数的         值。
★考核知识点：模块化及其C++实现
参见讲稿章节：5-1
附2.1.45：（考核知识点解释）
函数和外界的接口体现为参数传递和函数的返回值。
46、定义内联函数的关键字是         。
★考核知识点：模块化及其C++实现
参见讲稿章节：5-1
附2.1.46：（考核知识点解释）
定义内联函数的关键字是inline。
47、C++允许不同的函数具有相同的函数名，这就是函数         。
★考核知识点：函数重载
参见讲稿章节：5-4
附2.1.47：（考核知识点解释）
C++允许不同的函数具有相同的函数名，这就是函数重载。
48、要使用cin、         、endl等就必须包含该头文件         。
★考核知识点：编译预处理
参见讲稿章节：5-5
附2.1.48：（考核知识点解释）
要使用cin、cout、endl等就必须包含该头文件iostream。
49、         是一种编译预处理命令，即对某段程序代码中满足条件的语句进行编译、不满足条件的语句不进行编译。
★考核知识点：编译预处理
参见讲稿章节：5-5
附2.1.49：（考核知识点解释）
条件编译是一种编译预处理命令，即对某段程序代码中满足条件的语句进行编译、不满足条件的语句不进行编译。
50、编译预处理命令都是以         号开头。
★考核知识点：编译预处理
参见讲稿章节：5-5
附2.1.50：（考核知识点解释）
编译预处理命令都是以#号开头。
51         是指变量的寿命长短，即变量在整个程序运行过程中的哪个时间段是存在的，描述的是变量的时间属性。
★考核知识点：变量和函数的作用域和生存期
参见讲稿章节：5-7
附2.1.51：（考核知识点解释）
变量的生存期是指变量的寿命长短，即变量在整个程序运行过程中的哪个时间段是存在的，描述的是变量的时间属性。
52在32位系统中，内存地址由         位二进制数组成，即         个字节。
★考核知识点：数据存储的基本原理
参见讲稿章节：6-1
附2.1.52：（考核知识点解释）
在32位系统中，内存地址由32位二进制数组成，即4个字节。
53 C++中的指针是用于存放内存         的一种数据类型。
★考核知识点：地址与C++中的指针
参见讲稿章节：6-2
附2.1.53：（考核知识点解释）
C++中的指针是用于存放内存地址的一种数据类型。
54 数组名就是一个指针         ，表示该数组所占据内存空间的         。
★考核知识点：指针与数组
参见讲稿章节：6-3
附2.1.54：（考核知识点解释）
数组名就是一个指针常量，表示该数组所占据内存空间的首地址。
55 假设p为指针，n为正整数，则：
p+n：从p指向的地址开始的后面第         项数据的地址。p-n：从p指向的地址开始的前面第         项数据的地址。
★考核知识点：指针与数组
参见讲稿章节：6-3
附2.1.55：（考核知识点解释）
假设p为指针，n为正整数，则：
p+n：从p指向的地址开始的后面第n项数据的地址。p-n：从p指向的地址开始的前面第n项数据的地址。
56 使用         进行字符串输入操作时，实际上是将键盘上输入的字符串存储到指针所指向的内存空间中；使用         进行字符串输出操作时，实际上是将指针所指向的内存空间中的字符逐个取出并输出到屏幕上，直至遇到         结束。
★考核知识点：指针与字符串
参见讲稿章节：6-4
附2.1.56：（考核知识点解释）
使用cin进行字符串输入操作时，实际上是将键盘上输入的字符串存储到指针所指向的内存空间中；使用cout进行字符串输出操作时，实际上是将指针所指向的内存空间中的字符逐个取出并输出到屏幕上，直至遇到’\0’结束。
57 堆内存分配会失败时，系统会返回         。
★考核知识点：动态使用内存空间
参见讲稿章节：6-5
附2.1.57：（考核知识点解释）
堆内存分配会失败时，系统会返回0或假或false。
58 定义一个指针，用它指向一级指针变量所对应的内存         ，这种指向指针的指针就被称为         指针。
★考核知识点：二级指针
参见讲稿章节：6-6
附2.1.58：（考核知识点解释）
定义一个指针，用它指向一级指针变量所对应的内存地址，这种指向指针的指针就被称为二级指针。
59如果函数调用时传入的某个实参是字符型数组的首地址，则相应的形参应是
            类型的指针变量。
★考核知识点：指针与函数
参见讲稿章节：6-7
附2.1.59：（考核知识点解释）
如果函数调用时传入的某个实参是字符型数组的首地址，则相应的形参应是char类型的指针变量。
60变量的        就是变量的别名，对引用的操作就是对所引用            的操作。
★考核知识点：引用与函数
参见讲稿章节：6-8
附2.1.60：（考核知识点解释）
变量的引用就是变量的别名，对引用的操作就是对所引用变量的操作。
 
（二）、程序设计题
1、 请设计“求1-100所有5的倍数的数和”的算法，并写出C++程序。
参见讲稿章节：3-8
[答案]: 判断一个整数是5的倍数的方法是：判断该数是否能被5整除，能被5整除的数是5的倍数的数。所以，这是一个选择算法。需要选择出对1——100以内所有5的倍数的数和，这又是迭代算法。因此，解决该问题的算法是迭代和选择嵌套算法：
（1）用n来存储要判断的整数，sum存最终的结果
（2）对整数n（1——100），重复如下操作：
如果n除以5的余数为0
                则将你n累加到sum中。
C++参考程序如下：
#include<iostream>
using namespace std;
int main()
{
         int n,sum=0;
         for(n=1;n<=100;n++)
                   if(n%5==0)
                            sum=sum+n;
         cout<<” 1-100所有5的倍数的数和为：”<<sum;
         return 0;
}
2、可以根据用户输入的年份判断该年是否是闰年，直到用户输入0年停止处理。
参见讲稿章节：3-8
[答案]: 在学习双路选择问题时已经实现了判断某一年是否是闰年的问题。现在的问题是需要重复若干次这样的判断，直到用户输入的年份为0，这又是一个迭代算法。
解决该问题的迭代与选择嵌套算法如下表所示：

C++参考程序如下：
#include<iostream>
using namespace std;
int main()
{        int year;
         bool isLeapYear;
         cout<<“请输入一个年数(0退出程序)："<<endl;
         cin>>year;
         while (year!=0)
         {       
                   isLeapYear=(year % 4 == 0 && year%100 != 0)||(year%400 ==0);
                   if(isLeapYear)
                            cout<<year<<"年是闰年！"<<endl;
                   else
                            cout<<year<<"年不是闰年！"<<endl;
                   cout<<“请输入一个年数(0退出程序)："<<endl;
                   cin>>year;
         }
         return 0;
}
3、 请设计“求任意10个整数数的最小值”的算法，并写出C++程序。
参见讲稿章节：4-1，3.5, 3.1
[答案]: 用一个一维整形数组a来存储用户输入的10个整数。假设a[0]最小，通过循环依次在a[i](1<i<9)寻找是否有更小的。
C++参考程序如下：
#include<iostream>
using namespace std;
int main()
{
         int a[10],t;
         for(int i=0; i<10;i++)
                   cin<<a[i];
         t=0;
         for(int i=1;i<10;i++)
                   if(a[i]<a[t])
                            t=i;
         cout<<”输入的最小的整数为:”<<a[t];
         return 0;
}
4、 请设计“求n！”的递归算法，并用C++代码写出求n！的递归函数。
参见讲稿章节：5.2
[答案]: 求n!递归算法如下：
         如果n=1
                   则n！的值为1
         否则
                   n！的值为n*(n-1)!
C++参考程序如下：
int Fac(int x)                                                          //求n！的递归函数
{
         if (x == 1)
                   return 1;
         else
                   return x*Fac(x-1);                                         //函数的递归调用
}
5、 请设计“求斐波那契数列”的递归算法，并用C++代码写出该递归函数。
参见讲稿章节：5.2
[答案]: 求斐波那契数列（1,1,2,3,5,8,13,……,）第n项的的值的递归算法如下：
如果n=1或n=2
                   斐波那契数列的值为1
         否则
                   斐波那契数列的值为第n-1项与第n-2项和
C++参考程序如下：
int Fib(int n)                                                                                         //函数定义
{
                   if ( n==1 || n==2 )   
                            return 1;
                   else
                            return Fib(n-1)+Fib(n-2);                              //函数的递归调用
}
 
（三）读程序写结果题
1、下面程序运行的运行结果是什么？
#include<iostream>
using namespace std;
int main()
{
 int b='1';
 cout<<++b<<",";
 cout<<b+1<<endl;
 return 0;
}
参见讲稿章节：2.7
     参考答案：50,51
2、下面程序运行的运行结果是什么？
#include<iostream>
using namespace std;
int main()
{
 char a='1';
 cout<<++a<<",";
 cout<<a+1<<endl;
 return 0;
}
参见讲稿章节：2.7
     参考答案：2,51
3、下面程序的运行结果多少？
#include <iostream>
using namespace std;
int main()
{  
 int a=4,b=5,c=6,d=3;
 if(a>b)
  if(c>b)
   cout<< d+1;
  else
   cout<<++d+1;
 cout<<d<<endl;
 return 0;
}
参见讲稿章节：3.2
     参考答案：3
4、下面程序的运行结果是什么？
#include<iostream>
using namespace std;
int main()
{     int a=0;
    for(int x=0;!x && a<=10;a++)
    {  
         a++;
    }
    cout<<a<<endl;
    return 0;
}
参见讲稿章节：3.5
     参考答案：12
 
5、下面程序运行后的输出结果是什么？
#include<iostream>
using namespace std;
int main()
{
 int m=10;
 while(--m);
 m+=5;
 cout<<m;
 return 0;
}
参见讲稿章节：3.6
     参考答案：5
6、若i、j为整型变量，则下面程序段中的“cout<<i*j;”共执行多少次？
for(i=10; i; i--)
for(j=0; j<10; j++)
 {
  cout<<i*j;
 }
参见讲稿章节：3.7
     参考答案：100
7、下面程序的输出结果是什么？
#include<iostream>
using namespace std;
int main()
{
 int a[5]={15, 9, 5, 3, 1}, i=0, s1=0, s2=0;
 while (i<5)
 {
   if (a[i]%3)
    s1+=a[i];
   if (a[i]%5==0)
   s2+=a[i];
  i++;
 }
 cout<<s1<<','<<s2<<endl;
 return 0;
}
参见讲稿章节：4.1
     参考答案：6,20
8、下面程序的输出结果是什么？
#include <iostream>
using namespace std;
int main()
{
 char a[2][10]={"aBCDe","aBcDE"};
 int i;
 for (i=0; i<5; i++)
 {
  if(a[0][i]!=a[1][i])
   break;
 }
 if (i==5)
  cout<<"两个字符串相同"<<endl;
 else
 if (a[0][i]>a[1][i])
             cout<<"较大的字符串为："<<a[0]<<endl;
      else
             cout<<"较大的字符串为："<<a[1]<<endl;
 return 0;
}
参见讲稿章节：4.4
     参考答案：较大的字符串为：aBcDE
9、下面程序的输出结果是什么？
#include <iostream>
using namespace std;
struct Student
{
 char num[8];
 char name[10];
 int score;
};
int main()
{
 Student stu[3] = {{"1210101", "Zhangsan", 632},
  {"1210102", "Lisi", 626}, {"1210103", "Wangwu", 630}};
 int t=0;
 for(int i=0; i<3; i++)
  if (stu[i].score>t)
       t=stu[i].score;
 cout<<"t="<<t<<endl;
 return 0;
}。
参见讲稿章节：4.6
     参考答案：t=632
 
10、下面程序的运行结果是什么？
#include <iostream >
using namespace std;
int seq(int n)
{
 if (n == 1)
  return n;
 return 2*seq(n-1);
}
int main()
{
 int i, sum = 0;
 for (i = 1; i < 5; i++)
  sum += seq(i);
 cout<<sum<<endl;
 return 0;
}
参见讲稿章节：5.2
     参考答案：15
 
11、下面程序的运行结果是什么？
#include <iostream >
using namespace std;
double sum(double x, double y)
{
 return x+y;
}
int sum(int x, int y)
{
 return x+y;
}
int main()
{
 cout<<sum(5.3, 6.3)<<endl;
 cout<<sum(3, 5)<<endl;
 return 0;
}
参见讲稿章节：5.4
     参考答案：
11.6
        8
12、下面程序的输出结果是什么？
#include <iostream>
using namespace std;
int fun(int a,int b)
{
 static int n=2;
 int m=0;
 n+=m+a;
 m+=n+b;
 return m;
}
int main()
{
 int x=4, y=1, r1, r2;
 r1=fun(x, y);
 r2=fun(x, y);
 cout<<r1<<','<<r2<<endl;
 return 0;
}
参见讲稿章节：5.7
     参考答案：7,11
13、下面程序的运行结果是什么？
#include<iostream>
using namespace std;
#define Y 5+1
#define Z (5+1)
int main()
{
 cout<<3*Y<<endl;
 cout<<3*Z<<endl;
 return 0;
}
参见讲稿章节：5.5
     参考答案：
16
18
14、下面程序的运行结果是什么？
#include <iostream>
using namespace std;
int main()
{
 char name[20];
 gets(name); // 键入"Wang Tao"（"Wang"和"Tao"之间有一个空格）
 cout<<strlen(name)<<endl;
 cin>>name; // 键入"Li Xiaoming"（"Li"和"Xiaoming"之间有一个空格）
 cout<<strlen(name)<<endl;
 return 0;
}
参见讲稿章节：6.4
     参考答案：
              8
              2
15、下面程序的运行结果什么？
#include <iostream>
using namespace std;
int fun(int *p, int n)
{
 int i, m=p[0];
 for (i=1; i<n; i++)
  if (m<p[i])
   m=p[i];
 return m;
}
int main()
{
 int a[] = {1,2,3,4,5,6,7,8,9,10};
 cout<<fun(a+1, 3)<<endl;
 return 0;
}
参见讲稿章节：6.7
     参考答案：4
16、下面程序的运行结果是什么？
#include <iostream>
using namespace std;
void fun(char *p, int n)
{
 char t;
 for (int i=0; i<n/2; i++)
 {
  t = p[n-i-1];
  p[n-i-1] = p[i];
  p[i]=t;
 }
}
int main()
{
 char s[] = "abcde";
 fun(s, 5);
 cout<<s<<endl;
 return 0;
}
参见讲稿章节：6.7
     参考答案：edcba
17、下面程序的运行结果是什么？
#include <iostream>
using namespace std;
void fun(int &a, int b)
{
 int t = a;
 a = b;
 b = t;
}
int main()
{
 int a = 3, b = 5;
 fun(a, b);
 cout<<a<<','<<b<<endl;
 return 0;
}
参见讲稿章节：6.8
     参考答案：5,5
18、下面程序的运行结果是什么？
#include <iostream>
using namespace std;
void fun(int a, int b, int &sum, int sub)
{
 sum = a+b;
 sub = a-b;
}
int main()
{
 int a=5, b=10, sum=0, sub=0;
 fun(a, b, sum, sub);
 cout<<sum<<endl;
 cout<<sub<<endl;
 return 0;
}
参见讲稿章节：6.8
     参考答案：
15
0