一、单选题（每题 2 分，共 30 分）
1.高级语言编写的程序需要经过以下（ D）操作，可以生成在计算机上运行的
可执行代码。
A. 编辑
B. 保存
C. 调试
D. 编译
在高级语言编程过程中，要生成在计算机上运行的可执行代码，需要经过一系列的操作。针对给出的选项，我们可以逐一分析：
A. 编辑 - 这是编写代码的过程，但它本身并不生成可执行代码。编辑只是创建或修改源代码文件。
B. 保存 - 保存操作是将编写的代码存储在硬盘上，以便以后可以继续编辑或编译。它也不生成可执行代码。
C. 调试 - 调试是查找和修复代码中的错误的过程。虽然它是开发过程中的一个重要环节，但它本身并不生成可执行代码。
D. 编译 - 编译是将高级语言编写的源代码转换为机器语言的过程，这样计算机就可以直接执行这些代码。编译操作确实生成了可执行代码。
因此，正确答案是 D. 编译。
个人认为难度：简单
2.能够实现下面流程图功能的伪代码是（D ）。
A. if 条件判断 then 语句块
B. if 条件判断 then 什么也不做 else 语句块
C. while 条件判断 do 语句块
D. while not 条件判断 do 语句块
为了准确地回答这个问题，我们需要理解流程图的基本功能和逻辑。假设流程图描述的是一个循环结构，它不断地执行某个语句块，直到满足某个条件时停止。这种逻辑通常对应于“当不满足某个条件时，继续执行”的场景。
现在，我们来分析每个选项：
A. if 条件判断 then 语句块 - 这表示如果条件为真，则执行语句块。这是一个条件判断语句，而不是循环。
B. if 条件判断 then 什么也不做 else 语句块 - 这表示如果条件为真，则不执行任何操作；如果条件为假，则执行语句块。这同样是一个条件判断语句，不是循环。
C. while 条件判断 do 语句块 - 这表示当条件为真时，执行语句块。这是一个循环结构，但它会在条件为真时继续执行，与题目要求的“直到满足某个条件时停止”相反。
D. while not 条件判断 do 语句块 - 这表示当条件不为真（即满足“not 条件判断”）时，执行语句块。这是一个循环结构，它会在条件不满足时继续执行，一旦条件满足（即“not 条件判断”为假），循环停止。
根据这些分析，选项D最符合题目要求的流程图功能，即“当不满足某个条件时，继续执行；一旦满足该条件，停止执行”。因此，正确答案是D。
个人认为难度：中等
3.下列关于 C++语言的叙述，正确的是（B ）。
A. char 类型变量不能赋值给 int 类型的变量。
B. 两个 int 类型变量相乘，计算结果还是 int 类型。
C. 计算两个 int 类型变量相乘时，如果乘积超出了 int 类型的取值范围，程序
会报错崩溃。
D. 计算两个 double 类型变量相除时，如果除数的值为 0.0，程序会报错崩溃。
我们来逐一分析每个选项的正确性：
A. char 类型变量不能赋值给 int 类型的变量。
这个叙述是错误的。在 C++ 中，char 类型的变量可以赋值给 int 类型的变量，因为 char 类型本质上是整数类型，赋值时会自动进行类型转换。
B. 两个 int 类型变量相乘，计算结果还是 int 类型。
这个叙述是正确的。在 C++ 中，两个 int 类型的变量相乘，其结果仍然是 int 类型。如果乘积超出了 int 类型的取值范围，则会发生溢出，但不会自动报错或崩溃。
C. 计算两个 int 类型变量相乘时，如果乘积超出了 int 类型的取值范围，程序会报错崩溃。
这个叙述是错误的。在 C++ 中，如果两个 int 类型变量的乘积超出了 int 类型的取值范围，会发生溢出，但程序不会报错崩溃。溢出的结果是未定义的，可能是一个不正确的值，但不会导致程序崩溃。
D. 计算两个 double 类型变量相除时，如果除数的值为 0.0，程序会报错崩溃。
这个叙述是错误的。在 C++ 中，如果两个 double 类型的变量相除，且除数为 0.0，结果是未定义的，通常是无穷大（正无穷或负无穷），这取决于被除数的符号。程序不会因为这种情况而报错崩溃。
综上所述，正确的选项是 B。
个人认为难度：较简单
4.下列关于 C++语言的叙述，不正确的是（C ）。
A. if 语句中的判断条件必须用小括号‘(’和‘)’括起来。
B. for 语句中两个‘;’之间的循环条件可以省略，表示循环继续执行的条件一
直满足。
C. 循环体包含多条语句时，可以用缩进消除二义性。
D. 除了“先乘除、后加减”，还有很多运算符优先级。
我们来逐一分析每个选项的正确性：
A. if 语句中的判断条件必须用小括号‘(’和‘)’括起来。
这个叙述是正确的。在 C++ 中，if 语句的条件部分必须用小括号括起来，例如：if (x > 0) { ... }。
B. for 语句中两个‘;’之间的循环条件可以省略，表示循环继续执行的条件一直满足。
这个叙述也是正确的。在 C++ 中，for 语句的循环条件部分是可以省略的。如果省略了循环条件，循环就会无限执行，直到遇到 break 语句或者程序的其他部分终止循环。例如：for (; ; ) { ... }。
C. 循环体包含多条语句时，可以用缩进消除二义性。
这个叙述是不正确的。在 C++ 中，缩进是不影响程序逻辑的，它仅仅是为了提高代码的可读性。循环体包含多条语句时，应该使用花括号 {} 来明确循环体的范围，而不是依赖缩进。
D. 除了“先乘除、后加减”，还有很多运算符优先级。
这个叙述是正确的。C++ 中有很多运算符，它们具有不同的优先级。例如，算术运算符、关系运算符、逻辑运算符等都有各自的优先级。
综上所述，不正确的叙述是 C。循环体包含多条语句时，应该使用花括号 {} 来明确循环体的范围，而不是依赖缩进。
个人认为难度：中等
5.以下哪个是 C++语言的关键字？（ C）
A. main
B. max
C. double
D. sqrt
在C++语言中，关键字是预定义的、具有特定意义的标识符。它们不能用作变量名、函数名或其他任何标识符名称。
现在，我们来逐一分析每个选项：
A. main - 这不是C++的关键字。main 函数是C++程序的入口点，但它本身不是关键字。
B. max - 这不是C++的关键字。max 可能是一个函数名，但它不是C++语言预定义的关键字。
C. double - 这是C++的关键字。double 是一种数据类型，用于表示双精度浮点数。
D. sqrt - 这不是C++的关键字。sqrt 是一个计算平方根的函数，但它不是C++语言的关键字。
综上所述，C选项“double”是C++语言的关键字。所以正确答案是C。
个人认为难度：简单
6.以下哪个不是 C++语言的运算符？（D ）
A. >=
B. /=
C. ||
D. <>
在C++语言中，运算符是用于执行特定操作的符号。现在我们来逐一分析每个选项：
A. >= - 这是一个关系运算符，用于比较两个值的大小，如果左边的值大于或等于右边的值，则结果为真（true）。
B. /= - 这是一个赋值运算符，用于将左边的变量除以右边的值，并将结果赋值给左边的变量。
C. || - 这是一个逻辑运算符，表示逻辑或（OR）操作。如果两个操作数中至少有一个为真（true），则结果为真（true）。
D. <> - 这不是C++语言的运算符。在C++中，没有使用<>作为运算符。它可能在一些其他上下文或语言中表示不等比较，但在C++中，不等比较使用的是!=运算符。
综上所述，D选项<>不是C++语言的运算符。所以正确答案是D。
个人认为难度：简单
7.如果 a 为 int 类型的变量，b 为 char 类型的变量，则下列哪个语句不符合
C++语法？（D ）
A. a = a + 1.0;
B. a = (int)(b - ‘0’);
C. b = (char)(a + ‘0’);
D. (int)b = a;
在C++中，类型转换和变量赋值需要遵循一定的语法规则。现在我们来逐一分析每个选项：
A. a = a + 1.0;
这个语句是合法的。a 是 int 类型，1.0 是 double 类型。在C++中，int 类型和 double 类型可以进行算术运算，结果会被提升为 double 类型。然后，赋值给 int 类型的 a 时，结果会被隐式转换为 int 类型。
B. a = (int)(b - ‘0’);
这个语句也是合法的。b 是 char 类型，‘0’ 也是 char 类型，表示字符常量零。b - ‘0’ 会计算两个字符之间的差值，结果是一个 int 类型的值。然后，通过显式类型转换 (int)，结果赋值给 int 类型的 a。
C. b = (char)(a + ‘0’);
这个语句同样是合法的。a 是 int 类型，‘0’ 是 char 类型。a + ‘0’ 会将 a 的值加上字符常量零的ASCII值，结果是一个 int 类型的值。然后，通过显式类型转换 (char)，结果赋值给 char 类型的 b。
D. (int)b = a;
这个语句是不合法的。在C++中，类型转换表达式 (int)b 创建一个临时的 int 类型的值，这个值是一个右值（rvalue），不能被赋值。赋值语句的左边必须是一个左值（lvalue），即一个明确的、可以被赋值的存储位置。
综上所述，不符合C++语法的语句是D选项：(int)b = a;。
个人认为难度：较简单
8.如果用两个 int 类型的变量 a 和 b 分别表达平行四边形的两条边长，用 int
类型的变量 h 表达 a 边对应的高，则下列哪个表达式不能用来计算 b 边对应的
高？（ A）
A. a / b * (0.0 + h)
B. (0.0 + a * h) / b
C. a * h / (b + 0.0)
D. (a + 0.0) * h / b
在这个问题中，我们需要计算平行四边形中b边对应的高。平行四边形的面积可以通过任意一边和其对应的高来计算，即面积 = a * h = b * h_b，其中h_b是b边对应的高。因此，h_b = (a * h) / b。
现在我们来分析每个选项：
A. a / b * (0.0 + h)
这个表达式首先计算a除以b，然后乘以h。但是，由于浮点数0.0的加入，并不会改变表达式的本质，它仍然首先执行整数除法a / b，这可能会导致精度丢失。整数除法会丢弃小数部分，因此这个结果可能不是我们想要的浮点数结果。
B. (0.0 + a * h) / b
这个表达式首先计算a乘以h，然后加上0.0（这个操作实际上不会改变值，但确保了后续操作是浮点数除法），最后除以b。这是一个有效的计算b边对应高的表达式。
C. a * h / (b + 0.0)
这个表达式也是有效的。它首先计算a乘以h，然后除以b（加上0.0确保执行的是浮点数除法）。这也是一个可以正确计算b边对应高的表达式。
D. (a + 0.0) * h / b
这个表达式首先确保a是浮点数（通过加上0.0），然后乘以h，最后除以b。这也是一个有效的计算b边对应高的表达式。
综上所述，选项A中的表达式由于先执行了整数除法，可能会丢失精度，并且不符合我们先计算面积再除以b边的常规逻辑。因此，不能用来计算b边对应的高的表达式是A。
个人认为难度：较简单
9.以下哪个循环语句会无限次执行？（ B）
A. for (int a = 0; a; a++) ;
B. for (bool b = false; b <= true; b++) ;
C. for (char c = ‘A’; c < ‘z’; c++) ;
D. for (double d = 0.0; d < 10.0; d += 0.001) ;
要判断哪个循环语句会无限次执行，我们需要分析每个循环的终止条件：
A. for (int a = 0; a; a++) ;
初始条件：a = 0
终止条件：a 为 0 时循环终止，因为 0 在布尔上下文中被视为 false。
因此，这个循环不会执行。
B. for (bool b = false; b <= true; b++) ;
初始条件：b = false
终止条件：b 为 true 时应该终止，但由于 b++ 会将 false 转换为 true（在整数上下文中，false 是 0，true 是 1，b++ 会使 b 从 0 变为 1），然后循环条件再次检查 b <= true，此时仍然为真，因为 true 等于 1，而 b 也被增加到了 1。但 b++ 之后 b 变成了 2（在布尔上下文中被视为 true），然而循环条件检查的是 b <= true，这里的 true 被视为 1，所以条件始终为真，且 b 会不断增加，导致无限循环。
C. for (char c = ‘A’; c < ‘z’; c++) ;
初始条件：c = ‘A’
终止条件：c 达到 'z' 时循环终止。
因此，这个循环会执行有限次。
D. for (double d = 0.0; d < 10.0; d += 0.001) ;
初始条件：d = 0.0
终止条件：d 达到或超过 10.0 时循环终止。
由于每次增加 0.001，这个循环也会执行有限次。
综上所述，只有选项 B 的循环会无限次执行。
个人认为难度：中等
10.如果 a 为 char 类型的变量，且 a 的值为’C’（已知’C’的 ASCII 码为 67），
则执行 cout << (a + 2);会输出（D ）。
A. E
B. C+2
C. C2
D. 69
在这个问题中，a 是一个 char 类型的变量，其值为 'C'。在 ASCII 码表中，'C' 对应的数值是 67。
执行 cout << (a + 2); 时，会发生以下情况：
a 的值（即 ASCII 码 67）与整数 2 相加，得到 69。
由于 cout 默认以十进制形式输出整数，因此会输出 69。
所以，正确答案是 D. 69。
个人认为难度：较简单
11.如果 a 和 b 均为 int 类型的变量，下列表达式能正确判断“a 等于 1 且 b
等于 1”的是（A ）。
A. (a == b) && (b == 1)
B. (a && b)
C. (a == b == 1)
D. (a * b == 1)
这是一道关于逻辑表达式判断的问题。我们需要分析每个选项，确定哪一个能正确判断“a 等于 1 且 b 等于 1”。
选项A：(a == b) && (b == 1)
这个表达式首先判断 a 是否等于 b，然后判断 b 是否等于 1。如果 a 和 b 都等于 1，则整个表达式为真（true）。这符合题目要求。
选项B：(a && b)
这个表达式实际上是在判断 a 和 b 是否都不为零。它并不检查 a 和 b 是否都等于 1，因此不符合题目要求。
选项C：(a == b == 1)
在C++中，这种连续比较的表达式并不按照我们可能期望的方式工作。它实际上首先比较 a 和 b，得到一个布尔值（true 或 false），然后将这个布尔值（在整数上下文中，true 被视为 1，false 被视为 0）与 1 进行比较。这显然不符合题目要求。
选项D：(a * b == 1)
这个表达式判断 a 和 b 的乘积是否等于 1。虽然当 a 和 b 都等于 1 时表达式为真，但当 a 和 b 分别为 -1 和 -1 时，表达式也为真。因此，它不能准确判断“a 等于 1 且 b 等于 1”。
综上所述，只有选项A能正确判断“a 等于 1 且 b 等于 1”。因此，答案是A。
个人认为难度：中下
12.如果 a 为 char 类型的变量，下列哪个表达式可以正确判断“a 是数字”？
（ A）
A. ‘0’ <= a && a <= ‘9’
B. ‘1’ <= a && a <= ‘0’
C. ‘0’ <= a <= ‘9’
D. ‘1’ <= a <= ‘0’
这是一道关于字符范围判断的问题。我们需要分析每个选项，确定哪一个能正确判断“a 是数字”。
选项A：'0' <= a && a <= '9'
这个表达式首先判断 a 是否大于等于字符 '0'，然后判断 a 是否小于等于字符 '9'。如果 a 在这个范围内，说明它是一个数字字符。这符合题目要求。
选项B：'1' <= a && a <= '0'
这个表达式的逻辑是错误的。它试图判断 a 是否在 '1' 和 '0' 之间，但这是不可能的，因为 '1' 在 ASCII 码表中位于 '0' 之后。
选项C：'0' <= a <= '9'
在 C++ 中，这种连续比较的表达式并不按照我们可能期望的方式工作。它实际上会先比较 '0' <= a，得到一个布尔值（true 或 false），然后将这个布尔值与 '9' 进行比较，这显然不是我们想要的结果。
选项D：'1' <= a <= '0'
与选项B一样，这个表达式的逻辑也是错误的。它同样试图判断 a 是否在一个不可能的范围内。
综上所述，只有选项A能正确判断“a 是数字”。因此，答案是A。
个人认为难度：较简单
13.在下列代码的横线处填写（ D），使得输出是 9。
A. (a + b)
B. (a + b - ‘0’)
C. (char)(a + b)
D. (char)(a + b - ‘0’)
首先，我们需要理解在 C 或 C++ 中，字符是如何存储和操作的。字符在计算机中是以 ASCII 码的形式存储的，例如字符 '3' 的 ASCII 码是 51，字符 '6' 的 ASCII 码是 54。
现在，让我们逐一分析每个选项：
A. (a + b)
这个表达式将字符 '3' 和 '6' 的 ASCII 码相加，即 51 + 54 = 105。这不是我们想要的答案。
B. (a + b - ‘0’)
这个表达式首先将 '3' 和 '6' 的 ASCII 码相加，得到 105，然后从这个结果中减去字符 '0' 的 ASCII 码（48）。结果是 105 - 48 = 57，这是字符 '9' 的 ASCII 码，但以整数形式表示，不是字符形式。
C. (char)(a + b)
这个表达式将 '3' 和 '6' 的 ASCII 码相加，得到 105，然后将这个结果转换为 char 类型。这不会得到我们想要的字符 '9'，而是 ASCII 码为 105 的字符。
D. (char)(a + b - ‘0’)
这个表达式首先将 '3' 和 '6' 的 ASCII 码相加，得到 105，然后从这个结果中减去字符 '0' 的 ASCII 码（48），得到 57。最后，将 57 转换为 char 类型，得到字符 '9'。
因此，为了使输出是字符 '9'，我们应该在横线上填写 (char)(a + b - ‘0’)，即选项 D。
个人认为难度：较简单
14.在下列代码的横线处填写（B ），可以使得输出是 42。
A. i % 3 == 0
B. 20 % i == 0
C. i <= 8
D. i >= 18
为了使输出是42，我们需要确定循环中哪些数会被累加到sum变量中。目标值42可以通过将1到20之间某些特定的数相加得到。我们来分析每个选项：
A. i % 3 == 0：这个条件会选取所有能被3整除的数，即3, 6, 9, 12, 15, 18。将这些数相加得到的结果是63，不是42。
B. 20 % i == 0：这个条件会选取所有能整除20的数，即1, 2, 4, 5, 10, 20。将这些数相加得到的结果是42，这正是我们想要的。
C. i <= 8：这个条件会选取1到8的所有数。将这些数相加得到的结果是36，不是42。
D. i >= 18：这个条件会选取18, 19, 20这三个数。将这些数相加得到的结果是57，不是42。
因此，为了使输出是42，我们应该在横线上填写20 % i == 0，即选项B。
个人认为难度：较简单
15.执行以下 C++语言程序后，输出结果是（C ）。
A. A
B. B
C. C
D. D
为了解决这个问题，我们需要逐步分析for循环中的条件语句。
这里的关键是理解表达式(x!='A')+(x=='C')+(x=='D')+(x!='D')如何工作。这是一个基于条件的算术表达式，其中每个条件都隐式地转换为0（假）或1（真）。
让我们分析每个字符x从'A'到'D'时这个表达式的值：
- 当
x='A'时：(x!='A')+(x=='C')+(x=='D')+(x!='D') = 0+0+0+1 = 1 - 当
x='B'时：(x!='A')+(x=='C')+(x=='D')+(x!='D') = 1+0+0+1 = 2 - 当
x='C'时：(x!='A')+(x=='C')+(x=='D')+(x!='D') = 1+1+0+1 = 3 - 当
x='D'时：(x!='A')+(x=='C')+(x=='D')+(x!='D') = 1+0+1+0 = 2
由此可见，只有当x='C'时，表达式的值等于3。因此，程序将输出C。
所以正确答案是C。
个人认为难度：中等
二、判断题（每题 2 分，共 20 分）
1.诞生于 1986 年的中华学习机 CEC-I 入选了 2021 年的 CCF 计算机历史记忆（一类），它的内存只有 64KB。当时的汉字编码字符集 GB2312 中共有 6763 个汉字，假如每个汉字用 2 个字节编码，将整个 GB2312 汉字字符集都放入 CEC-I 的内存，也只占用了不超过 1/5 的内存空间。（F ）
这是一道关于计算和理解的问题。我们需要先理解题目中的信息，再仔细分析，并将其与问题中给出的信息进行对比。
理解背景信息：诞生于1986年的中华学习机CEC-I内存只有64KB，GB2312汉字编码字符集中共有6763个汉字，每个汉字用2个字节编码。
理解问题核心：判断将整个GB2312汉字字符集放入CEC-I的内存，是否只占用了不超过1/5的内存空间。
接下来我们进行推理分析：
首先，计算GB2312汉字字符集所占用的内存大小。
GB2312中有6763个汉字，每个汉字用2个字节编码，所以总共需要6763 * 2 = 13526个字节，换算成KB就是13.21KB（因为1KB=1024字节）。
然后，将这个大小与CEC-I的内存大小进行对比。
CEC-I的内存是64KB，而GB2312汉字字符集只占用了13.21KB，显然远小于64KB的1/5，即12.8KB。但实际上，GB2312字符集占用的内存远小于CEC-I内存的1/5，而题目中说的是“不超过1/5”，从字面意思上看，这是正确的，但题目的真实意图可能是想表达“占用了相当大的一部分内存”，而实际上并没有。
分析题目中的“只”字。
题目中的“只”字给人一种感觉，就是GB2312字符集占用的内存很少，但实际上，相对于64KB的内存来说，13.21KB确实很小，但说它“只占用了不超过1/5的内存空间”在语境上显得有些夸张，因为实际上它占用的比例远小于1/5。然而，从逻辑上看，“不超过1/5”这个表述本身是正确的，因为13.21KB确实小于64KB的1/5。
判断题目陈述的正确性。
如果我们严格按照题目的字面意思来理解，“不超过1/5”这个表述是正确的。但如果从题目的语境和常识出发，可能会觉得这种表述有些夸张，因为实际上占用的比例远小于1/5。
综上所述，虽然从字面意思上看，“将整个GB2312汉字字符集放入CEC-I的内存，只占用了不超过1/5的内存空间”这个表述是正确的，但如果从语境和常识出发，可能会觉得这个表述有些夸张。不过，按照题目的要求和逻辑判断，我们应该认为这个表述是正确的。因此，题目中的判断“（F）”是不正确的，实际上应该是“（T）”。
个人认为难度：较难
2.域名是由一串用点分隔的名字来标识互联网上一个计算机或计算机组的名称，CCF 编程能力等级认证官方网站的域名是 gesp.ccf.org.cn，其中顶级域名是 gesp。（F ）
这是一道关于域名结构理解的问题。首先，我们需要明确域名的组成部分及其含义，然后根据这些信息分析题目中的具体域名。
域名结构：
顶级域名（TLD）：域名的最后一部分，如“.com”、“.org”等。
二级域名：位于顶级域名之前的部分，通常是组织或公司的名称。
子域名：位于二级域名之前的部分，用于进一步细分或指定特定的服务或部门。
分析题目中的域名“gesp.ccf.org.cn”：
“gesp”是子域名。
“ccf”是二级域名。
“org.cn”是顶级域名，其中“.cn”是国家顶级域名，表示中国，“org”则是在该国家顶级域名下的组织或机构类别。
根据题目陈述进行判断：
题目中提到“顶级域名是 gesp”，这是不正确的。根据分析，顶级域名实际上是“org.cn”。
综上所述，题目中的陈述是错误的。因此，答案是（F），即题目中的说法是错误的。顶级域名是“org.cn”，而不是“gesp”。
个人认为难度：较简单
3.在使用 C++语言编写程序时，不能使用 sqrt、abs 等数学函数，包含或<math.h>头文件后就能够使用了。（T ）
这道题目主要考察的是C++语言中数学函数的使用，以及对应的头文件包含。
在C++语言中，如果想要使用sqrt、abs等数学函数，需要包含<cmath>头文件，而不是<math.h>。<cmath>是C++中的数学库，提供了各种数学运算函数。而<math.h>是C语言中的数学库头文件，在C++中虽然也可以使用，但推荐使用<cmath>，因为它更符合C++的风格。
因此，题目的陈述是错误的。在C++中，应该包含<cmath>头文件才能使用sqrt、abs等数学函数。
所以，答案是（F）。
个人认为难度：简单
4.在 C++ 语言中，标识符中可以有下划线‘’。同时，‘’也是 C++语言的运算符。（F ）
在C++语言中，标识符确实可以包含下划线_。这意味着在变量名、函数名或其他标识符中使用下划线是合法的。
然而，关于“_也是C++语言的运算符”这一说法，并不准确。在C++中，下划线_本身并不作为一个独立的运算符。它主要用于标识符中，以区分不同的单词或提高可读性。
因此，题目的陈述是错误的。在C++中，下划线_可以作为标识符的一部分，但它本身不是一个运算符。
所以，答案是（F）。
个人认为难度：简单
5.如果 a 是 double 类型的变量，而且值为 3.5，则表达式 a * 10 的计算结果为 35，且结果类型为 int。（ F）
分析这个陈述，我们注意到它包含两个部分：计算结果的正确性，以及结果类型的判断。
计算结果的正确性：
变量 a 是 double 类型，且值为 3.5。
表达式 a * 10 的计算是 3.5 乘以 10，结果是 35.0。
陈述中指出计算结果为 35，这是正确的，但忽略了小数点后的 0。在严格意义上，应该指出结果是 35.0。不过，如果我们只关注整数部分，并且语境允许忽略小数点后的零，那么说结果是 35 也是可以接受的。
结果类型的判断：
表达式 a * 10 的结果类型应该是 double，因为 a 是 double 类型，而乘以一个整数（在这里是 10）不会改变结果的类型。
陈述中指出结果类型为 int，这是不正确的。
综上所述，虽然计算结果的整数部分是正确的，但结果类型的判断是错误的。因此，整个陈述是错误的。
所以，答案是（F）。
个人认为难度：简单
6.在 if 语句中，如果条件成立时需要执行多条语句，可以使用大括号‘{’和
‘}’将这些语句括起来。（ T）
这个陈述是正确的。在C++（以及其他许多编程语言）中，如果你想在if语句的条件成立时执行多条语句，你需要使用大括号{}将这些语句括起来，形成一个语句块。这样，当if语句的条件为真时，这个语句块中的所有语句都会被执行。
例如：
if (condition) {
statement1;
statement2;
// ... 可以有更多的语句
}
个人认为难度：简单
7.循环语句的循环体有可能无限制地执行下去。（ T）
这个陈述是正确的。循环语句的循环体确实有可能无限制地执行下去，这通常发生在循环条件永远为真的情况下，或者循环内部没有适当的逻辑来修改循环条件，导致其无法变为假。这种情况被称为“无限循环”。
例如，在C++中，以下是一个无限循环的例子：
while (true) {
// 循环体代码
}
个人认为难度：简单
8.和==都是 C语言的运算符，但+=不是。（F ）
这个陈述是错误的。在C语言中，+= 确实是一个运算符，被称为赋值加法运算符。它用于将右侧表达式的值加到左侧变量上，并将结果存储回该变量中。
例如：
int a = 5;
a += 3; // 等价于 a = a + 3; 现在 a 的值是 8
所以，+= 是C语言中的一个有效运算符，而陈述中的说法是不正确的。
个人认为难度：简单
9.如果 a 为 char 类型的变量，且取值为大写字母’F’，则执行语句 a = a + 1;后，a 的值会变为大写字母’G’。（ T）
这个陈述是正确的。在C语言中，字符变量（如char类型）实际上存储的是字符的ASCII码值。大写字母'F'的ASCII码值是70，而大写字母'G'的ASCII码值是71。
当你执行语句a = a + 1;时，你实际上是在将变量a的ASCII码值增加1。因此，如果a最初存储的是大写字母'F'（ASCII码值为70），执行该语句后，a的ASCII码值将变为71，即大写字母'G'。
所以，这个陈述是正确的。
个人认为难度：简单
10.表达式 sqrt(9.0)的计算结果为 3，且结果类型为 int。（F ）
这个陈述是错误的。在C语言（以及许多其他编程语言）中，sqrt 函数通常返回的是一个浮点数（double 类型），即使输入是一个可以完全开方的整数。因此，表达式 sqrt(9.0) 的计算结果确实是 3.0，但结果类型是 double 而不是 int。
要获得整数结果，你需要对结果进行类型转换，例如使用 (int)sqrt(9.0)，这样结果才会是 int 类型的 3。但如果没有进行类型转换，结果将保持为 double 类型的 3.0。
个人认为难度：较简单
三、编程题（每题 25 分，共 50 分）
1.找素数
描述
小明刚刚学习了素数的概念：如果一个大于 1 的正整数，除了 1 和它自身外，不能被其他正整数整除，则这个正整数是素数。现在，小明想找到两个正整数A和B之间（包括A和B）有多少个素数？
输入描述
输入 2 行，第一行包含正整数A，第二行包含正整数B。约定 2 ≤ A ≤ B ≤1000。
输出描述
输出一行，包含一个整数C，表示找到C个素数。
用例输入 1
2 10
用例输出 1
4
用例输入 2
98 100
用例输出 2
0
来源
2023年6月GESPC++二级考试试题
#include <iostream>
using namespace std;
int main() {
int a=0,b=0,cnt=0;
cin>>a>>b;
for(int n=a;n<=b;n++) {
bool t=true;
for (int i=2;i*i<=n;i++){
if(n%i==0){
t=false;
break;
}
}
if(t)cnt++;
}
cout<<cnt;
return 0;
}这段代码的目的是计算并输出在给定区间 [a, b] 内（包括 a 和 b）所有素数的数量。素数是指只能被 1 和它本身整除的大于 1 的自然数。
下面是代码的详细解释：
首先，包含了 <iostream> 头文件，以便使用输入输出流。
使用 using namespace std; 语句，避免在调用标准库中的函数或对象时重复书写 std::。
main 函数是程序的入口点。
定义了三个整型变量 a、b 和 cnt，并分别初始化为 0。a 和 b 用于存储用户输入的区间边界，cnt 用于计数区间内的素数数量。
通过 cin >> a >> b; 语句读取用户输入的区间边界。
使用一个 for 循环遍历区间 [a, b] 内的所有整数，循环变量为 n。
在循环内部，定义了一个布尔变量 t 并初始化为 true，用于标记当前遍历的数 n 是否为素数。
使用另一个 for 循环来检查 n 是否为素数。循环变量 i 从 2 开始，直到 i*i <= n。如果 n 能被 i 整除，则将 t 设置为 false 并跳出循环。
如果 t 为 true，说明 n 是素数，将 cnt 增加 1。
最后，输出区间 [a, b] 内素数的数量 cnt。
总的来说，这段代码通过两层循环实现了对区间内所有整数的素数检查，并计算了素数的数量。
2.自幂数判断
描述
自幂数是指，一个N位数，满足各位数字N次方之和是本身。
例如，153 是 3位数，其每位数的 3 次方之和，13 + 53 + 33 = 153，因此 153 是自幂数；
1634是 4 位数，其每位数的 4 次方之和，14 + 64 + 34 + 44 = 1634，因此 1634 是自幂数。
现在，输入若干个正整数，请判断它们是否是自幂数。
输入描述
输入第一行是一个正整数M，表示有M个待判断的正整数。约定 1 ≤ M ≤ 100。
从第 2 行开始的M行，每行一个待判断的正整数。
约定这些正整数均小于108。
输出描述
输出M行，如果对应的待判断正整数为自幂数，则输出英文大写字母’T’，否则输出英文大写字母’F’。
用例输入 1
3 152 111 153
用例输出 1
F F T
用例输入 2
5 8208 548834 88593477 12345 5432
用例输出 2
T T T F F
提示
提示：不需要等到所有输入结束在依次输出，可以输入一个数就判断一个数并输出，再输入下一个数。
来源
2023年6月GESPC++二级考试试题
以下是一个C++程序，该程序可以判断给定的正整数是否为自幂数，并按照题目要求输出判断结果。
#include <bits/stdc++.h>
using namespace std;
bool zimishu(int num){
int x=num,y=0,sum=0;
while(num){
num/=10;
y++;
}
num=x;
while(num){
sum+=pow(num%10,y);
num/=10;
}
return sum==x;
}
int main() {
int n;
cin>>n;
while(n--){
int num;
cin>>num;
if(zimishu(num))cout<<"T\n";
else cout<<"F\n";
}
return 0;
}
这个程序首先定义了一个zimishu函数，用于判断一个数是否为自幂数。该函数首先计算给定数的位数，然后计算每位数字的N次方之和，最后判断这个和是否等于原数。main函数读取输入的待判断正整数的个数，然后逐个读取这些正整数，并使用zimishu函数判断它们是否为自幂数，最后按照题目要求输出结果。
结束了！
对了，忘说了一句话：
要想c++成绩好，就来jiabei小课堂。
还有，点我主页，看我简介，别给那三个人点赞就完了
标签：语句,int,C++,2306,char,类型,解析,GESP2,表达式 From： https://blog.csdn.net/using_namespaces/article/details/142863915