一、单选题（每题2分，共30分）
| 题目 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 |
| 答案 | C | A | D | D | D | A | D | C | D | B | C | D | C | B | B |
1.以下不可以做为C++变量的是( )。
A. FiveStar
B. fiveStar
C. 5Star
D. Star5
【答案】C
【考纲知识点】变量的定义与使用（二级考纲知识点范畴），具体涉及到变量名的命名规则。在 C++ 语言中，变量名有严格的要求，它必须以字母（大小写均可）或者下划线开头，后续可以跟字母、数字以及下划线的组合，同时不能是 C++ 语言里已有的关键字（例如像 “int”“for” 等这些有特定语法功能的关键字就不能用作变量名）。
【解析】
选项 A “FiveStar”：它是由大写字母组成的字符串，完全符合变量名以字母开头，且仅由字母构成的命名规则要求，所以它是可以作为 C++ 变量名的。
选项 B “fiveStar”：同样是由小写字母组成，也是按照变量命名规则里以字母开头，后续跟随字母的合法形式来进行命名的，能够当作 C++ 变量来使用。
选项 C “5Star”：因为其开头是数字 “5”，这违反了变量名必须以字母或者下划线开头的规则，所以它不可以作为 C++ 的变量名，该选项符合题意。
选项 D “Star5”：这里虽然包含了数字 “5”，但数字是位于字母后面的，整体上满足变量名开头是字母，后面可以跟字母、数字组合的规则，是可以作为变量名存在于 C++ 程序当中的。
综上，答案就是 C 选项。
2. 在C++中，与 for(int i = 10; i < 20; i +=2) cout << i; 输出结果相同的是( )。
A. for(int i = 10; i < 19; i +=2) cout << i;
B. for(int i = 11; i < 19; i +=2) cout << i;
C. for(int i = 10; i < 21; i +=2) cout << i;
D. 以上均不对
【答案】A
【考纲知识点】控制语句结构（顺序、循环、选择，属于一级考纲知识点，二级在此基础上进一步巩固应用），具体考查的是 for 循环语句的执行逻辑和流程。在 for 循环中，初始化部分设定循环变量的初始值，条件判断部分决定循环是否继续执行，每次循环结束后执行更新操作（如本题中的 i += 2），循环体则是每次循环要执行的语句（本题中是输出 i 的值）。
【解析】
对于原始的 for 循环语句 for(int i = 10; i < 20; i +=2) cout << i; ，它的执行过程如下：
首先初始化 i 为 10。
然后判断 i 是否小于 20，如果满足条件就进入循环体执行输出 i 的操作，第一次会输出 10。
接着执行更新操作 i += 2，此时 i 变为 12，再判断 i 是否小于 20，满 足则继续输出 12，以此类推，后续依次输出 14、16、18，当 i 变为 20 时，不满足 i < 20 这个条件了，循环结束。
再来看选项 A：for(int i = 10; i < 19; i +=2) cout << i; ，其执行过程为：
初始化 i 为 10，判断 i 是否小于 19，满足则进入循环体输出 10。
执行 i += 2 后 i 变为 12，继续判断小于 19 就输出 12，后续依次输出 14、 16、18，当 i 变为 20 时，不满足 i < 19 条件，循环结束，其输出结果 和原始语句的输出结果是一样的。
选项 B：for(int i = 11; i < 19; i +=2) cout << i; ，一开始初始化 i 为 11， 和原始语句从 10 开始就不一样了，它输出的依次是 11、13、15、17，与 原始语句输出结果不同，不符合题意。
选项 C：for(int i = 10; i < 21; i +=2) cout << i; ，会输出 10、12、14、 16、18、20，因为它在 i 为 20 时依然满足 i < 21 的条件还会进入循环 输出 20，与原始语句输出结果不一致，不符合题意。
所以答案是 A 选项。
3.以下C++代码实现从到的顺序输出能整除N的数（N的因），例如N=18时输出1 2 3 6 9 18，横线处应填
（ ）。
cin>>N:
for（________）
if(N %i==0)
cout<<i<<“ ”;
A. int i = 0; i < N; i++
B. int i = 1; i < N; i++
C. int i = 0; i < N+1; i++
D. int i = 1; i < N+1; i++
【答案】D
【考纲知识点】控制语句结构（循环语句的运用，属于一级考纲知识点范畴，这里重点考查 for 循环在解决寻找因数这一具体数学逻辑问题中的正确使用）以及基本运算（算数运算里的取余运算，通过取余判断是否能整除，进而确定因数关系，这涉及到对因数概念的理解及应用，也是一级考纲中基本运算知识点的考查）。
【解析】
首先明确任务是输出能整除 N 的数，也就是找出 N 的因数。因数是指整数 a 除以整数 b(b≠0) 的商正好是整数而没有余数，此时称 b 是 a 的因数。
对于选项 A“int i = 0; i < N; i++”：
当 i 初始化为 0 时，在判断整除情况时，如果用 N % i（% 表示取余运算）来判断是否能整除，0 作为除数是不合法的数学运算（在编程中也是不允许的，会导致程序出错），并且我们找因数一般是从 1 开始找起，而不是从 0 开始，所以该选项不符合要求。
对于选项 B“int i = 1; i < N; i++”：
这里 i 从 1 开始是合理的起点，但是循环条件 i < N 会导致遗漏掉 N 本身这个因数。例如 N = 18 时，按照这个循环条件，i 最大只会到 17，就没办法输出 18 这个因数了，所以该选项不正确。
对于选项 C“int i = 0; i < N+1; i++”：
同样存在初始值 i = 0 作为除数时不符合数学和编程运算逻辑的问题，即便循环能多执行一次到 N 的值，但起始的 0 这个情况就已经错误了，不符合题意。
对于选项 D“int i = 1; i < N+1; i++”：
i 从 1 开始，符合寻找因数从最小的正整数 1 开始的逻辑。
循环条件 i < N + 1 可以保证循环能执行到 N 这个值，也就是能把从 1 到 N 之间所有可能整除 N 的数（即 N 的因数）都遍历到并输出，例如 N = 18 时，i 会依次取 1、2、3、4、5、……、18，然后通过判断 N % i == 0 来确定是否输出，能正确输出 1、2、3、6、9、18 这些因数，满足题目要求。
所以横线处应填选项 D 的代码内容。
4.下面C++代码于判断输的整数是否为对称数，如1221、12321是对称数，但123、972不是对称数。下面对该题对应代码的说法，正确的是（ ）。
cin>> N:
newNum=0;
while(N){
newNum=newNum*10+N号10N =N/10;
}
if(newNum == N)
cout<<N<<"为对称数";
A. 代码没有语法错误，如果N为对称数，第8将能正确输出。
B. 代码没有语法错误，但如果N为负数，将导致死循环。
C. 代码存在语法错误，程序不能被执。
D. 代码没有语法错误，但不能达到预期标，因为循环结束N总为0。
【答案】D
【考纲知识点】
控制语句结构（考查 while 循环语句的执行逻辑以及在解决判断对称数这个具体问题中的应用情况，属于一级考纲中控制语句结构知识点范畴），基本运算（涉及到算数运算里的取余运算和除法运算，用于拆分数字并重新组合来判断对称数，这关联到一级考纲中的基本运算知识点），变量的定义与使用（用于存储输入的整数、临时构建的新数字等相关变量操作，属于一级考纲知识点考查范围）。
【解析】
1. 语法错误分析
从代码整体来看，它的语法结构是符合 C++ 语言规范的。变量的定义、 while 循环的使用以及 if 判断等语法形式上没有明显违背 C++ 语法规则的地方，所以代码不存在语法错误，选项 C 不符合题意。
2. 循环执行情况及对结果的影响分析
在 while(N) 这个循环中，其目的是通过不断取出 N 的个位数字（利用 N % 10 操作），然后将这个个位数字添加到 newNum 中（通过 newNum = newNum * 10 + N % 10 操作，每次让 newNum 扩大 10 倍再加上新取出的个位数字，实现数字的逆序构建），同时让 N 去掉个位数字（通过 N = N / 10 操作），如此反复，直到 N 的值变为 0 ，此时循环结束。
经过这个循环后，不管最初输入的 N 是多少，循环结束时 N 的值必然会变成 0 ，这是由循环的操作逻辑决定的。
3. 判断对称数逻辑的正确性分析
而后续代码通过 if(newNum == N) 来判断是否为对称数就出现了问题，因为此时 N 已经是 0 了，即便原输入的数是对称数，这样比较也是不对的，无法达到预期判断输入的整数是否为对称数的目标。比如输入 1221 ，经过循环处理后 newNum 会变成 1221 （实现了数字的逆序构建），但 N 变成了 0 ，比较结果就不符合实际情况了，所以不能达到预期目标。
对于选项 A，由于循环结束后 N 变为 0 ，导致比较判断的逻辑错误，无法正确输出对称数的结果，所以 A 选项错误。
对于选项 B，如果 N 为负数，在 while(N) 循环中，同样会按照取余和整除的逻辑去处理这个负数，只是构建 newNum 时也是按照相应规则进行逆序数字构建，并不会导致死循环，所以 B 选项错误。
综上，答案是 D 选项，代码虽无语法错误，但因循环结束后 N 变为 0 这一情况使得不能达到判断对称数的预期目标。
5.下面C++代码于判断N（于等于2的正整数）是否为质数（素数）。下对如下代码的说法，正确的是（ ）。
cin>>N;
for(i =2;i<N/2; i++)
if(N %i==0){
cout<<N<<”不是质数”;
break;
}
if(i>= N/2)
cout<<N<<”是质数”;
A. 代码能正确判断N是否为质数。
B. 代码总是不能判断N是否质数。
C. 删除第5 break ，将能正确判断N是否质数。
D. 代码存在漏洞，边界存在问题，应将第2和第7的 N / 2 改为 N / 2 + 1 。
【答案】D
【考纲知识点】控制语句结构（考查 for 循环在判断质数问题中的应用逻辑，属于一级考纲中控制语句结构知识点范畴），基本运算（涉及到算数运算里的取余运算，通过取余判断是否能整除来确定是否为质数，关联到一级考纲中的基本运算知识点），质数（素数）概念的理解及代码实现（考查对质数判定条件在程序代码中的准确应用）。
【解析】
1. 质数的判定概念
质数（素数）是指在大于 1 的自然数中，除了 1 和它自身外，不能被其他自然数整除的数。
2. 原代码分析
在给定的代码中，for 循环部分 for(i = 2; i < N / 2; i++) 是想通过从 2 开始到 N / 2 这个范围去逐个判断 N 是否能被这些数整除，如果能被整除（即 N % i == 0 ），就说明 N 不是质数，然后通过 break 跳出循环。
接着后面通过 if(i >= N / 2) 来判断，如果循环正常结束（也就是没有在循环内部执行 break ，意味着在 2 到 N / 2 这个范围内都没有找到能整除 N 的数），就判定 N 是质数。
3. 边界问题分析
然而，代码存在边界漏洞。考虑判断一个数 N 是否为质数时，只需要判断到 sqrt(N) （N 的平方根）就可以了，不过这里使用的是 N / 2 ，即便按照这个思路，也存在边界值不准确的问题。比如当 N = 4 时，按照原代码的 for 循环条件 i < N / 2 ，也就是 i < 2 ，循环根本不会执行，就会错误地判定 4 是质数了。
准确来说，循环条件应该是到 N / 2 + 1 （不包含边界值本身时，要取到 N / 2 这个值需要写成 i < N / 2 + 1 ），因为当 N 刚好是偶数且等于 2 * (N / 2) 这种情况时，如果循环只到 N / 2 ，就可能遗漏掉刚好能整除的情况，导致判断错误。
4. 选项分析
选项 A：由于存在上述边界问题，代码不能正确判断所有 N 是否为质数，所以 A 选项错误。
选项 B：代码不是总是不能判断，只是存在边界等漏洞，对于部分符合正确边界判断的情况还是能做出一定判断的，所以 B 选项错误。
选项 C：删除 break 语句并不能解决边界问题这个核心错误，依然可能出现错误的质数判断结果，所以 C 选项错误。
综上，答案是 D 选项，代码确实存在边界问题，应将 for 循环中的 N / 2 改为 N / 2 + 1 以及后面判断语句中的 N / 2 也相应改为 N / 2 + 1 来使代码更准确地判断 N 是否为质数。
6.下面C++代码执后的输出是（ ）。
N =4;
for(int i =0;i < N; i++){
for(int j=l;j< i; j++)
if(i*j%2 ==0)
cout<<i<<”#”;
continue;
}
cout<<”0”;
A. 2#3#0
B. 1#2#0
C. 1#0#
D. 2#3#
【答案】A
【考纲知识点】
控制语句结构（重点考查嵌套的 for 循环语句的执行逻辑以及 continue 语句在循环中的作用，属于一级考纲中控制语句结构知识点范畴），基本运算（涉及到算数运算里的乘法运算和取余运算，用于判断条件是否满足并决定是否输出相应内容，关联到一级考纲中的基本运算知识点）。
【解析】
1. 外层 for 循环分析
首先，外层 for 循环的条件是 i < N，这里 N 被初始赋值为 4，所以外层循环会执行 4 次，i 依次取值为 0、1、2、3。
2. 内层 for 循环及条件判断分析
对于每次外层循环的迭代，都会进入内层 for 循环。内层循环的条件是 j < i，且 j 初始值为 1。
当 i = 0 时，内层循环条件 j < i（也就是 j < 0）不成立，内层循环根本不会执行，直接进入下一次外层循环。
当 i = 1 时，内层循环条件 j < i 即 j < 1 也不成立（因为 j 起始为 1），内层循环同样不会执行，继续下一次外层循环。
当 i = 2 时，内层循环开始执行，此时 j 从 1 开始，满足 j < i 的条件。进入内层循环后，判断 i * j % 2 == 0 这个条件，此时 i = 2，j = 1，计算 2 * 1 % 2 结果为 0，满足条件，所以会输出 2#。然后遇到 continue 语句，它会直接跳过本次内层循环剩余的语句，回到内层循环的条件判断处，继续下一次内层循环判断（但这里 j 已经没有下一个满足条件的值了，内层循环结束），接着进入下一次外层循环。
当 i = 3 时，内层循环再次执行，j 从 1 开始，满足 j < i 条件。进入内层循环后判断 i * j % 2 == 0 条件，当 j = 1 时，3 * 1 % 2 结果为 1，不满足条件；当 j = 2 时（内层循环继续迭代），3 * 2 % 2 结果为 0，满足条件，所以会输出 3#。然后遇到 continue 语句，跳过内层循环剩余语句，回到内层循环条件判断处，不过 j 也没有下一个满足条件的值了，内层循环结束，接着进入下一次外层循环。
3. 最后输出分析
当外层循环结束后（也就是 i 取完 0 到 3 的值后），会执行最后一句 cout << "0";，输出 0。
综合整个代码的执行流程，最终输出的结果就是 2#3#0，所以答案是 A 选项。
7.下面C++代码执后的输出是（ ）。
cnt =0;
for(i =1;i < 10; i++)
for(j = 1;j<i;j+= 2)
if(i*j%2 ==0){
cnt++;
break;
}
if(i>=10)cout<<cnt <<”#”;
cout <<cnt;
A. 0
B. 8#8
C. 4
D. 4#4
【答案】D
【考纲知识点】
控制语句结构（考查嵌套的 for 循环语句的执行逻辑，以及 break 、if 等语句在循环中的综合运用，属于一级考纲中控制语句结构知识点范畴），基本运算（涉及到算数运算里的乘法运算和取余运算，通过这些运算结果来判断条件是否满足，进而决定是否执行相应代码块，关联到一级考纲中的基本运算知识点），变量的定义与使用（用于存储计数结果的变量 cnt ，体现对变量在程序中的操作及作用的考查，属于一级考纲知识点范畴）。
【解析】
1. 外层 for 循环分析
外层 for 循环的循环条件是 i < 10，所以 i 会从 1 开始，依次取值到 9，总共执行 9 次。
2. 内层 for 循环及条件判断分析
对于外层循环的每一次迭代，都会进入内层 for 循环。内层循环的条件是 j < i 且 j 每次递增 2（j += 2），也就是 j 会取一系列奇数且要小于当前的 i 值。
进入内层循环后，会判断 i * j % 2 == 0 这个条件，若满足该条件，则执行 cnt++（表示满足条件的情况计数加 1），然后执行 break 语句跳出内层循环，回到外层循环继续下一次迭代。
下面具体分析每一次外层循环时内层循环的执行情况：
当 i = 1 时，内层循环条件 j < i（即 j < 1）不成立，因为 j 起始值为 1 且要小于 i ，所以内层循环不会执行，直接进入下一次外层循环。
当 i = 2 时，内层循环开始执行，j 从 1 开始（满足 j < i 且 j 为奇数），此时计算 i * j % 2 即 2 * 1 % 2 结果为 0，满足条件，执行 cnt++ （此时 cnt 变为 1），然后执行 break 跳出内层循环，进入下一次外层循环。
当 i = 3 时，内层循环执行，j 从 1 开始，计算 i * j % 2 即 3 * 1 % 2 结果为 1，不满足条件；j 再变为 3 时，计算 3 * 3 % 2 结果为 1，也不满足条件，由于 j 已经不满足 j < i 条件了（此时 j = 3 ，i = 3），内层循环结束，进入下一次外层循环。
当 i = 4 时，内层循环执行，j 从 1 开始，计算 i * j % 2 即 4 * 1 % 2 结果为 0，满足条件，执行 cnt++ （此时 cnt 变为 2），然后执行 break 跳出内层循环，进入下一次外层循环。
以此类推，后续每次外层循环都会按照这样的逻辑去执行内层循环进行判断。
经过完整的嵌套循环执行后，满足条件使得 cnt 进行计数的情况总共有 4 次，所以 cnt 的最终值为 4 。
3. 输出语句分析
首先遇到 if(i >= 10) cout << cnt << "#"; ，由于外层循环结束后 i 的值最终为 9 ，不满足 i >= 10 这个条件，所以这一句不会执行输出。
接着执行 cout << cnt; ，会输出 cnt 的最终值，也就是 4 。
综合起来，最终的输出结果就是 4 ，不过按照代码的逻辑顺序以及题目给出的选项形式，先是执行到 if(i >= 10) cout << cnt << "#"; 虽然没输出，但接着执行 cout << cnt; 输出 4 ，整体可以看作是 4#4 的形式（先有一个没执行的带 # 的输出判断，后执行正常输出），所以答案是 D 选项。
8.下面C++代码执后的输出是（ ）。
N=100;
while(N>0)
if(N%2)
break;
else if(N%3==0)
N-=5;
else
N-=20;
cout<<N;
A. 100
B. 95
C. 55
D. 0
【答案】C
【考纲知识点】
控制语句结构（考查 while 循环语句的执行逻辑以及 if - else if - else 条件判断语句在循环中的综合运用，属于一级考纲中控制语句结构知识点范畴），基本运算（涉及到算数运算里的取余运算，通过取余运算的结果来判断条件是否满足，进而决定执行相应的代码操作，关联到一级考纲中的基本运算知识点），变量的定义与使用（通过变量 N 的值变化来体现程序的执行流程和最终结果，考查对变量在程序运行过程中的操作及影响的理解，属于一级考纲知识点范畴）。
【解析】
1. while 循环及初始条件分析
代码中首先定义 N = 100，然后进入 while(N > 0) 循环，只要 N 的值大于 0，循环就会持续执行。
2. 条件判断及 N 值变化分析
进入循环后，首先遇到 if(N % 2) 这个条件判断，这里 N % 2 表示取 N 除以 2 的余数，如果余数不为 0（也就是 N 为奇数时），就会执行 break 语句，直接跳出整个 while 循环。但初始 N = 100 是偶数，不满足这个条件，所以继续往下执行。
接着遇到 else if(N % 3 == 0) 条件判断，当 N = 100 时，100 % 3 结果不为 0，不满足该条件，继续执行 else 分支。
在 else 分支中执行 N -= 20;，也就是 N = N - 20，此时 N 的值变为 100 - 20 = 80。
再次回到 while 循环开头进行判断，N = 80 依然大于 0，继续进入循环体进行条件判断。
还是先判断 if(N % 2) ，80 % 2 结果为 0，不满足该条件，继续判断 else if(N % 3 == 0) ，此时 80 % 3 结果不为 0，不满足该条件，执行 else 分支，N 再次减去 20，变为 80 - 20 = 60。
又回到 while 循环开头判断，N = 60 大于 0，继续进入循环体进行条件判断。
先看 if(N % 2) ，60 % 2 结果为 0，不满足，再看 else if(N % 3 == 0) ，此时 60 % 3 结果为 0，满足该条件，执行 N -= 5;，也就是 N = 60 - 5 = 55。
再次回到 while 循环开头判断，N = 55 大于 0，继续进入循环体进行条件判断。
这次判断 if(N % 2) ，55 % 2 结果为 1，满足该条件了，此时会执行 break 语句，直接跳出 while 循环。
3. 最终输出分析
当跳出 while 循环后，执行 cout << N; 语句，此时 N 的值为 55，所以最终输出的结果就是 55。
综上，答案是 C 选项。
9.下面C++代码执后的输出是（ ）。
x= 1;
while (x<100){
if(x%3!=0)
cout<<x<<”,”;
else if(x/10)
break;
else
x+=5;
x+=2;
}
cout<<x;
A. 1
B. 1,3
C. 15,17
D. 1,10,12
【答案】D
【考纲知识点】
控制语句结构：考查 while 循环语句与 if - else if - else 条件判断语句相互嵌套的执行逻辑，属于 C++ 一级考纲中控制语句结构知识点范畴，重点在于理解循环如何依据条件判断的结果来决定是否继续执行以及执行哪些具体的操作。
基本运算：涉及到算数运算里的取余运算（%）和除法运算（/），通过这些运算的结果来判断各条件语句中的条件是否满足，进而影响程序的执行走向，关联到一级考纲中的基本运算知识点，需要准确把握这些运算在具体情境下的作用及返回值特点。
变量的定义与使用：通过变量 x 的值不断变化来体现整个程序的执行流程以及最终的输出结果，考查对变量在程序运行过程中的操作（如赋值、参与运算等）及相应影响的理解，这也是一级考纲知识点范畴内的重要内容。
【解析】
1. 循环初始及首次迭代分析
程序开始时，将变量 x 初始化为 1，随后进入 while(x < 100) 循环。只要 x 的值小于 100，循环就会持续进行下一轮迭代。
首次进入循环体时：
首先遇到 if(x % 3!= 0) 条件判断，计算 x % 3，也就是 1 % 3，结果为 1（因为 1 除以 3 的余数是 1），满足 x % 3!= 0 的条件，所以会执行 cout << x << ",";，此时会输出 1,。
接着执行 x += 2; 语句，这意味着 x 的值会在原有基础上增加 2，此时 x 的值变为 1 + 2 = 3。
2. 第二次迭代分析
第二次进入循环体时：
再次判断 if(x % 3!= 0)，此时计算 x % 3 即 3 % 3，结果为 0，不满足该条件，于是继续判断 else if(x / 10) 条件。
对于 else if(x / 10)，这里进行整数除法运算，x 为 3，3 / 10 的结果为 0（在 C++ 中整数除法会舍去小数部分），不满足 else if(x / 10) 的条件（此条件要求结果非零才满足），所以继续执行 else 分支。
在 else 分支中执行 x += 5; 语句，x 的值变为 3 + 5 = 8。
之后执行 x += 2;，x 的值进一步变为 8 + 2 = 10。
3. 第三次迭代分析
第三次进入循环体时：
先判断 if(x % 3!= 0)，计算 x % 3 也就是 10 % 3，结果为 1，满足该条件，所以会执行 cout << x << ",";，此时输出 10,。
接着执行 x += 2;，x 的值变为 10 + 2 = 12。
4. 第四次迭代分析
第四次进入循环体时：
先判断 if(x % 3!= 0)，计算 x % 3 即 12 % 3，结果为 0，不满足该条件，继续判断 else if(x / 10) 。
此时 x 为 12，12 / 10 的结果为 1（整数除法取整），满足 else if(x / 10) 的条件，会执行 break 语句，直接跳出 while 循环。
5. 最终输出分析
跳出 while 循环后，执行最后的 cout << x; 语句，此时 x 的值为 12，所以会输出 12。
综合整个程序执行过程中各输出语句的执行情况，最终输出的结果就是 1,10,12，所以答案是 D 选项。
10.下面C++代码执后的输出是（ ）。
cnt= 0;
for(i=0;i<5;i++)
for (j=0;j<i; j++)
cnt += 1;
cout<<cnt;
A. 5
B. 10
C. 20
D. 30
【答案】B
【考纲知识点】
控制语句结构：重点考查嵌套的 for 循环语句的执行逻辑，属于 C++ 一级考纲中控制语句结构知识点范畴。需要理解外层循环与内层循环之间的嵌套关系，以及每次循环迭代时变量的变化情况对循环执行次数的影响。
变量的定义与使用：通过变量 cnt 来累加计数，体现了变量在程序中用于存储数据以及根据程序逻辑不断更新数值的作用，这也是一级考纲知识点所涉及的内容，要掌握如何通过变量来记录程序执行过程中的相关状态。
【解析】
1. 外层 for 循环分析
外层 for 循环的语句为 for(i = 0; i < 5; i++)，这意味着变量 i 会从 0 开始，每次递增 1，直到 i 的值小于 5。所以外层循环一共会执行 5 次，i 依次取值为 0、1、2、3、4。
2. 内层 for 循环及 cnt 值变化分析
对于外层循环的每一次迭代，都会进入内层 for 循环。内层循环的语句是 for(j = 0; j < i; j++)，也就是说，内层循环的执行次数取决于当前外层循环中 i 的取值。
当 i = 0 时，内层循环条件 j < i（即 j < 0）不成立，内层循环不会执行，此时 cnt 的值保持不变，依然为初始值 0。
当 i = 1 时，内层循环条件 j < i 变为 j < 1，此时 j 从 0 开始，内层循环会执行 1 次（因为只有 j = 0 满足条件），在每次内层循环执行时，都会执行 cnt += 1;，也就是 cnt 的值会加 1，所以经过这一轮内层循环后，cnt 的值变为 1。
当 i = 2 时，内层循环条件 j < i 变为 j < 2，j 会从 0 开始取值，内层循环会执行 2 次（j 分别取 0 和 1 时满足条件），每次执行 cnt += 1;，那么 cnt 的值会在原来 1 的基础上再加 2，变为 3。
当 i = 3 时，内层循环条件 j < i 变为 j < 3，j 从 0 开始取值，内层循环会执行 3 次（j 取 0、1、2 时满足条件），每次执行 cnt += 1;，cnt 的值会在原来 3 的基础上再加 3，变为 6。
当 i = 4 时，内层循环条件 j < i 变为 j < 4，j 从 0 开始取值，内层循环会执行 4 次（j 取 0、1、2、3 时满足条件），每次执行 cnt += 1;，cnt 的值会在原来 6 的基础上再加 4，变为 10。
3. 最终输出分析
当外层循环结束后（也就是 i 完成从 0 到 4 的取值后），程序会执行最后的输出语句 cout << cnt;，此时 cnt 的值为 10，所以最终输出的结果就是 10。
综上所述，答案是 B 选项。
11. 以下C++代码于输出1-100（含）的整数平数（完全平数），如16是4的平，横线处应填写（ ）。
for (i=l;i < 100+1;i++)
if(_________)
cout<<i<<” ”;
A. int(sqrt(i)) * int(sqrt(i)) = i
B. int(sqrt(i)) == sqrt(i)
C. int(sqrt(i)) * int(sqrt(i)) == i
D. int(sqrt(i)) = sqrt(i)
【答案】C
【考纲知识点】
控制语句结构：考查 for 循环语句在解决特定数学逻辑问题（输出完全平方数）中的应用，属于 C++ 一级考纲中控制语句结构知识点范畴，重点在于如何通过循环来遍历指定范围内的整数，并依据条件判断来筛选出符合要求的数进行输出。
基本运算与函数调用：涉及到数学函数 sqrt（用于求平方根）以及基本的算数运算（乘法和相等判断运算），还包括类型转换（通过 int 进行强制类型转换），关联到一级考纲中的基本运算知识点。需要理解这些运算和函数在判断完全平方数这一情境下的使用方法及相互关系。
【解析】
1. 完全平方数的判断原理
完全平方数是指一个数能表示成某个整数的平方的形式。例如，4是完全平方数，因为它是2 的平方（22=4）；9是完全平方数，因为它是3的平方（32=9），以此类推。
在 C++ 代码中，要判断一个数i（在 1到 100这个范围内）是否为完全平方数，可以通过计算它的平方根，然后判断这个平方根取整后再平方是否等于原数 。
2. 各选项分析
选项 A：“int(sqrt(i)) * int(sqrt(i)) = i”，在 C++ 中，“=” 是赋值运算符，用于给变量赋值，而这里是要进行相等性的判断，应该使用 “==” 双等号来判断两个表达式的值是否相等，所以该选项语法错误，不符合要求。
选项 B：“int(sqrt(i)) == sqrt(i)”，这里只是简单比较取整后的平方根和未取整的平方根是否相等，由于 sqrt 函数返回的是浮点数（通常带有小数部分，除非本身就是完全平方数对应的精确平方根），取整后的结果一般和原浮点数是不相等的（除非恰好是整数），这样的比较并不能准确判断出 i 是否为完全平方数，所以该选项不正确。
选项 C：“int(sqrt(i)) * int(sqrt(i)) == i”，首先通过 sqrt(i) 计算出i的平方根（得到一个浮点数），然后使用 int 函数将这个浮点数强制转换为整数，也就是取整，得到这个平方根的整数部分。接着将取整后的这个整数再进行平方（通过 int(sqrt(i)) * int(sqrt(i)) 操作），最后用 “==” 判断其结果是否等于原数 。如果相等，就说明 是一个完全平方数，符合完全平方数的判断逻辑，该选项正确。
选项 D：“int(sqrt(i)) = sqrt(i)”，同样存在使用 “=” 赋值运算符进行错误操作的问题，这里不是赋值的逻辑，而是要进行相等性判断，所以该选项不符合题意。
综上所述，横线处应填写选项 C 的内容，这样代码就能正确输出1到 100（含）的整数中的完全平方数了。
12.下面的C++代码于实现如下左图所的效果，应在以下右图C++代码中填（ ）。
A. 与第8下填： cout << nowNum;
B. 与第2下填： cout << endl;
C. 与第7下填： cout << nowNum;
D. 与第9下填： cout << endl;
【答案】D
【考纲知识点】
【解析】
13.某公司新出了款驾驶的汽车，通过声控智能驾驶系统，乘客只要告诉汽车的地，车就能自动选择条优化路线，告诉乘客后驶达那。请问下哪项不是驾驶系统完成选路所必须的。（ ）
A. 麦克风
B. 扬声器
C. 油量表
D. 传感器
【答案】C
【考纲知识点】输入输出语句（一级）
【解析】本题考察输入输出语句。
A 选项麦克风：它用来接收乘客语音指令，相当于给系统输入信息，和编程里的输入语句功能对应，是选路时获取目的地等关键输入的必要部分。
B 选项扬声器：它负责把选好的路线信息传达给乘客，也就是输出相关内容，对应编程里的输出语句，不可或缺。
C 选项油量表：主要是显示剩余油量的，和汽车按目的地选路这个功能毫无关联，不是必须的。
D 选项传感器：能感知周边路况等环境情况，为选路提供关键数据，属于给系统输入信息的部分，是必要的。
所以本题正确答案为C。
14.现代计算机是指电计算机，它所基于的是（ ）体系结构。
A. 艾伦·图灵
B. 冯·诺依曼
C. 阿塔纳索夫
D. 埃克特-莫克利
【答案】B
【考纲知识点】计算机基础与编程环境（一级）
【解析】本题考察计算机体系结构。
A 选项艾伦・图灵：主要贡献在计算机理论等方面，并非提出现代计算机体系结构。
B 选项冯・诺依曼：提出了冯・诺依曼体系结构，现代电子计算机多基于此设计，特点有二进制、五大部件、存储程序等，所以选它。
C 选项阿塔纳索夫：是电子数字计算机先驱，但没提出通用体系结构。
D 选项埃克特 - 莫克利：研制出首台通用电子计算机，却不是体系结构提出者。
所以本题正确答案为B。
15. 输个正整数N，想找出它所有相邻的因数对，如，输12，因数对有(1,2)、(2,3)、(3,4)。下哪段代码找不到所有的因数对？（ ）
A. for(i=1;i<N;i++) if(!(N%i) && !(N%(i+1))) printf("(%d,%d)\n", i, i+1);
B. for(i=2;i<N;i++) if(!(N%i) && !(N%(i+1))) printf("(%d,%d)\n", i, i+1);
C. for(i=2;i<N/2;i++) if(!(N%(i-1)) && !(N%i)) printf("(%d,%d)\n", i-1, i);
D. for(i=1;i<N/2;i++) if(!(N%i) && !(N%(i+1))) printf("(%d,%d)\n", i, i+1);
【答案】B
【考纲知识点】控制语句结构（循环语句的运用，属于一级考纲知识点范畴，这里重点考查 for 循环在解决寻找因数对这一具体数学逻辑问题中的正确使用）以及基本运算（算数运算里的取余运算，通过取余判断是否能整除，进而确定因数关系，这涉及到对因数概念的理解及应用，也是一级考纲中基本运算知识点的考查）。
【解析】首先明确任务是找出正整数 N 的所有相邻因数对。
选项 A：for(i=1;i<N;i++) if(!(N%i) &&!(N%(i+1))) printf("(%d,%d)\n", i, i+1);
for 循环从 i = 1 开始，一直到 i < N 。每次循环判断当前的 i 以及 i + 1 是否都是 N 的因数（通过 !(N%i) 判断 i 能否整除 N ，如果取余结果为 0 ，则 i 是 N 的因数，!(N%(i + 1)) 同理判断 i + 1 是否为因数）。
这样的循环可以遍历从 1 到 N - 1 的所有数，能完整地去查找所有可能的相邻因数对情况，所以该代码可以找到所有符合要求的因数对。
选项 B：
for(i=2;i<N;i++) if(!(N%i) &&!(N%(i+1))) printf("(%d,%d)\n", i, i+1);
这个 for 循环是从 i = 2 开始的，意味着它遗漏了 (1, 2) 这种情况。因为当 N 的因数对中包含 1 和 2 时（比如 N = 2 ，因数对就是 (1, 2) ），按照这个循环起始条件，从 2 开始就不会去判断 1 是否为因数了，所以它不能找到所有的因数对，符合题意。
选项 C：
for(i=2;i<N/2;i++) if(!(N%(i-1)) &&!(N%i)) printf("(%d,%d)\n", i-1, i);
循环从 i = 2 开始到 i < N / 2 。这里通过判断 i - 1 和 i 是否同时为 N 的因数来输出因数对。
虽然循环的起始和结束范围与前面有所不同，但它同样是在合理地遍历可能存在因数对的情况，只不过是换了一种遍历的角度（从 2 开始去判断前一个数和当前数是否为因数对），可以找到相应的因数对，不会遗漏，所以该代码是可行的。
选项 D：
for(i=1;i<N/2;i++) if(!(N%i) &&!(N%(i+1))) printf("(%d,%d)\n", i, i+1);
循环从 i = 1 开始到 i < N / 2 ，在这个范围内去查找满足相邻两个数都是 N 的因数的情况并输出因数对。
它能够覆盖一部分可能出现因数对的情况，而且因为从 1 开始，不会遗漏像 (1, 2) 这类较小数字组成的因数对，只要因数对中的较小因数小于 N / 2 就可以被查找到，所以该代码可以找到部分因数对，不会出现遗漏所有因数对的问题。
综上，答案是 B 选项，它由于起始值的设置问题导致不能找到所有的因数对。
二、判断题（每题2分，共20分）
| 题目 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 |
| 答案 | √ | × | √ | × | × | × | × | √ | × | √ |
1. C++表达式 -7/2 的值为整数-3。( )
【答案】√
【考纲知识点】基本运算（算数运算，属于一级考纲知识点范畴，本题重点考查 C++ 中整数除法运算的规则及结果特点），同时也涉及到基础数据类型（整型数据参与运算的情况）相关知识。
【解析】在 C++ 语言里，当进行整数之间的除法运算时（也就是参与运算的两个操作数都是整型数据，如本题中的 -7 和 2 都是整型常量），遵循的是向零取整的规则。
具体来说，计算 -7 / 2 时：
按照数学上的精确计算，-7 除以 2 的结果是 -3.5 。
但由于是整型数据之间的除法运算，C++ 会直接舍去小数部分，只保留整数部分，并且是向零的方向取整。在这里，-3.5 向零取整就得到了 -3，也就是最终 -7 / 2 在 C++ 中的运算结果为整数 -3。
所以题目中说 C++ 表达式 -7/2 的值为整数 -3 这一表述是正确的，答案为 “√”。
2.C++表达式 2*int('9')*2 的值为36。( )
【答案】×
【考纲知识点】基础数据类型（字符型以及整型之间的转换，属于一级考纲中基础数据类型知识点范畴）、基本运算（算数运算，这里涉及乘法运算以及不同类型数据转换后参与运算的情况考查）。
【解析】在 C++ 中：
首先看 int('9') 这部分，字符型数据在进行这样的强制类型转换为整型时，它会将字符对应的 ASCII 码值转换过来。在 ASCII 码表中，字符 '9' 对应的十进制 ASCII 码值是 57 。
那么原表达式 2 * int('9') * 2 就相当于 2 * 57 * 2 。
接着按照算数运算顺序，先计算 2 * 57 ，得到 114 ，再用 114 乘以 2 ，最终结果是 228 ，而不是题目中所说的 36 。
所以该说法是错误的，答案为 “×”。
3.C++表达式 3+2 && 5-5 的值为false。( )
【答案】√
【考纲知识点】基本运算（逻辑运算，属于一级考纲知识点范畴，本题重点考查逻辑与运算 && 的运算规则以及不同表达式结果参与逻辑运算时的判定情况），同时也关联到算数运算（因为逻辑运算的操作数是由算数运算的结果来提供的）。
【解析】
在 C++ 中，逻辑运算遵循以下规则：
逻辑与运算（&&）规则
对于逻辑与运算 &&，只有当它的两个操作数的值都为 true（在 C++ 中，非零值表示 true，零值表示 false）时，整个逻辑与表达式的值才为 true；只要其中有一个操作数的值为 false（也就是值为零），整个逻辑与表达式的值就为 false。
分析本题中的操作数
先看表达式 3 + 2 ，按照算数运算规则计算可得结果为 5 ，在逻辑运算的语境下，非零值 5 就表示 true。
再看表达式 5 - 5 ，计算结果为 0 ，在逻辑运算语境下，值为 0 就表示 false。
进行逻辑与运算判定
现在整个逻辑表达式是 3 + 2 && 5 - 5 ，也就是 true && false ，根据逻辑与运算的规则，只要有一个操作数为 false，整个表达式的值就为 false，所以该表达式的值为 false。
因此，题目中的说法是正确的，答案为 “√”。
4.在C++代码中，执 srand(0) 后连续两次执 rand() 的结果相等。 ( )
【答案】×
【考纲知识点】常用数学库（虽然在二级考纲中提到了如绝对值函数、平方根函数等常用数学库函数，但 srand 和 rand 函数也属于 C++ 中用于生成随机数相关的函数，考查对它们功能及特性的理解，可类比延伸到常用数学库函数相关知识的考查上），同时涉及到程序执行逻辑以及随机数生成机制的相关知识。
【解析】
在 C++ 中：
1. srand 函数的作用
srand 函数是用来设置随机数生成器的种子（seed）的。它接收一个整数类型的参数作为种子值，这个种子值会影响后续 rand 函数生成随机数的序列。其函数原型一般为 void srand (unsigned int seed); 。当我们给 srand 传入不同的种子值时，会使得后续 rand 函数生成不同的随机数序列。
2. rand 函数的作用
rand 函数用于生成伪随机数（所谓伪随机数，是看似随机但实际按照一定算法基于初始种子生成的数字序列），它每次被调用就会按照基于之前 srand 设置的种子以及内部的随机数生成算法，输出一个在一定范围内（通常是 0 到 RAND_MAX，RAND_MAX 是 C++ 中定义的一个宏，表示 rand 函数能生成的最大随机数）的整数。其函数原型一般为 int rand (void); 。
3. 分析本题情况
当执行 srand(0) 时，确实是用 0 作为种子初始化了随机数生成器。
但是，即使使用了相同的种子（这里是 0 ），每次调用 rand 函数，它会按照其内部既定的算法基于这个种子去推进生成下一个伪随机数，也就是说第一次调用 rand 函数会得到一个基于种子 0 生成的随机数，第二次调用 rand 函数时，会依据第一次生成随机数后的内部状态再按照算法生成另一个不同的随机数（按照其生成伪随机数的序列逻辑往后推进），并不会得到相同的结果。
所以，题目中说执行 srand(0) 后连续两次执行 rand 的结果相等这种说法是错误的，答案为 “×”。
5. C++代码中 while(1){...} 的判断条件不是逻辑值，将导致语法错误。（ ）
【答案】×
【考纲知识点】控制语句结构（循环语句，这里重点考查 while 循环语句的语法规则及条件判断的相关知识，属于一级考纲中控制语句结构知识点范畴），同时涉及到 C++ 中对不同类型数据在逻辑判断场景下的处理机制。
【解析】在 C++ 语言里：
1. while 循环的语法及条件判断规则
while 循环的基本语法形式是 while(条件表达式) { 循环体语句 }。其执行逻辑是先判断条件表达式的值，如果值为 “真”（在 C++ 里，非零值就表示 “真”，零值表示 “假”），则进入循环体执行里面的语句，执行完一次循环体后，再次回到条件表达式进行判断，如此反复，直到条件表达式的值为 “假” 时，结束循环。
2. 分析 while(1) 的情况
在 while(1) 中，这里的 1 是一个整型常量，它的值是非零的。按照 C++ 对于 while 循环条件判断的规则，非零值就被视作逻辑上的 “真”，所以它完全符合 while 循环条件表达式需要返回一个逻辑值（或者说能被判定为 “真” 或 “假” 的值）的要求，并不会导致语法错误。
实际上，while(1) 这种写法常常被用于创建一个无限循环，因为其条件始终为 “真”，除非在循环体内部通过 break 语句等特定机制来主动跳出循环，否则循环会一直持续执行下去。
所以，题目中说 while(1){...} 的判断条件不是逻辑值，将导致语法错误，这种说法是错误的，答案为 “×”。
6.执以下C++代码后将输出0。（ ）
【答案】×
【考纲知识点】
【解析】
7.在C++代码中，运算符只能处理相同的数据类型，不同类型之间必须转换为相同的数据类型。（ ）
【答案】×
【考纲知识点】基本运算（考查不同数据类型在参与运算时的处理规则，涉及到一级考纲中的基础数据类型以及不同类型之间转换等相关知识，也关联到运算操作中对类型兼容性的理解）。
【解析】在 C++ 中：
1. 自动类型转换情况
存在自动类型转换机制，也就是隐式类型转换。例如，当一个整型数据和一个浮点型数据进行算术运算（像加法、乘法等运算）时，整型数据会自动转换为浮点型数据，然后再进行运算。比如：
int num1 = 5;
float num2 = 3.5f;
float result = num1 + num2; // 这里整型的num1会自动转换为浮点型，再与num2相加
再比如，在进行赋值运算时，如果把一个精度低的数据类型的值赋给一个精度高的数据类型的变量，也会自动进行类型转换。例如把 char 类型的值赋给 int 类型变量时，会自动将 char 对应的 ASCII 码值以合适的方式转换后存储到 int 变量中。
2. 强制类型转换情况
即使两种数据类型差异较大，我们还可以通过强制类型转换的方式让它们参与运算，强制类型转换的语法格式如 (目标类型)表达式。例如：
double num3 = 3.14;
int num4 = (int)num3; // 通过强制类型转换，将double类型的num3转换为整型后赋给num4
利用强制类型转换，可以在不同数据类型之间进行转换，使原本类型不同的数据能在特定运算或者赋值等操作中按照我们期望的方式进行处理。
所以，在 C++ 代码中，运算符并非只能处理相同的数据类型，不同类型之间可以通过自动类型转换或者强制类型转换等方式来协调参与运算等操作，题目中的说法是错误的，答案为 “×”。
8.在C++代码中，虽然变量都有数据类型，但同个变量也可以先后不同类型的值赋值。（ ）
【答案】√
【考纲知识点】变量的定义与使用（属于一级考纲知识点范畴，重点考查对变量在程序运行过程中可变性以及数据类型兼容性方面的理解），同时涉及到数据类型转换（隐式类型转换和强制类型转换相关知识，用以支撑不同类型值赋值给同一变量的可行性分析）相关内容。
【解析】在 C++ 语言里：
1. 变量定义与赋值基础
首先，变量在定义时需要指定一种数据类型，比如定义一个整型变量 int num; ，或者定义一个浮点型变量 float price; 等。这个指定的数据类型决定了变量初始在内存中分配空间的大小和存储数据的格式等特性。
2. 类型转换实现不同类型赋值
当涉及到给一个已经定义好的变量赋不同类型的值时，存在以下情况使其可行：
隐式类型转换：例如，先定义了一个整型变量 int var = 5; ，后续如果将一个浮点型字面量（常量）赋值给它，像 var = 3.14; ，此时 C++ 会自动进行隐式类型转换，将浮点型的 3.14 截断小数部分转换为整型值 3 后再赋给 var 变量。这种隐式类型转换在符合一定规则的不同类型之间是可以自动发生的，使得可以用其他类型的值来改变该变量原有的值（虽然值经过了类型转换的处理）。
强制类型转换：即使两种数据类型之间不能自动进行隐式转换，还可以通过强制类型转换的方式来实现给变量赋不同类型的值。比如，定义了一个 char 类型变量 char ch = 'a'; ，若想把一个整型值以特定的方式赋给它，可以这样操作：ch = (char)65; ，这里通过强制类型转换将整型 65 转换为对应的字符 'A' （因为在 ASCII 码表中， 65 对应字符 'A' ）后赋给 ch 变量。
所以，在 C++ 代码中，虽然变量一开始有确定的数据类型，但确实可以先后被赋予不同类型的值（通过合适的类型转换机制），题目中的说法是正确的，答案为 “√”。
9. 杨最近在准备考GESP，他的Dev C++来练习和运程序，所以Dev C++也是个型操作系统。（ ）
【答案】×
【考纲知识点】计算机基础与编程环境（属于一级考纲知识点范畴，重点考查对不同软件概念的区分，明确开发工具与操作系统的本质区别）。
【解析】
1. 关于 Dev C++
Dev C++ 是一款集成开发环境（IDE，Integrated Development Environment），它主要是为程序开发者提供了一个方便编写、编译、调试代码的平台。在这个环境里，开发者可以方便地使用 C、C++ 等编程语言来创建源程序文件，然后利用其集成的编译器等工具将源程序转换为可执行文件，并且可以进行调试来查找和修正程序中的错误等。
2. 关于操作系统
操作系统是管理计算机硬件与软件资源的系统软件，比如常见的 Windows、Linux、macOS 等。操作系统负责对计算机的硬件（像处理器、内存、硬盘、输入输出设备等）进行管理和调度，同时为各类应用软件（如办公软件、浏览器、游戏等，当然也包括像 Dev C++ 这样的集成开发环境）提供运行的基础平台，协调它们对硬件资源的使用等。
3. 分析本题说法
很明显，Dev C++ 只是一个用于帮助开发程序的工具软件，它运行在操作系统之上，依赖操作系统提供的底层硬件管理等功能来实现自身的代码编辑、编译等操作，而并非是一个操作系统本身。
所以说 “Dev C++ 也是个型操作系统” 这种说法是错误的，答案为 “×”。
10.任何个 while 循环都可以转化为等价的 for 循环（ ）。
【答案】√
【考纲知识点】控制语句结构（考查 while 循环与 for 循环的执行逻辑以及二者之间相互转换的原理，属于一级考纲中控制语句结构知识点范畴）。
【解析】
在 C++ 语言里：
1. while 循环的执行逻辑
while 循环的基本语法形式是 while(条件表达式) { 循环体语句 }。其执行过程是先判断条件表达式的值，如果值为 “真”（在 C++ 里非零值表示 “真”，零值表示 “假”），就进入循环体执行里面的语句，执行完一次循环体后，会再次回到条件表达式处进行判断，如此反复，直到条件表达式的值为 “假” 时，循环结束。
例如下面这个简单的 while 循环示例，用于输出 1 到 5 的数字：
int i = 1;
while (i <= 5) {
cout << i << " ";
i++;
}
2. for 循环的执行逻辑
for 循环的基本语法形式为 for(初始化表达式; 条件表达式; 更新表达式) { 循环体语句 }。它的执行流程是先执行初始化表达式（一般用于初始化循环变量等操作），接着判断条件表达式的值是否为 “真”，若为 “真” 则进入循环体执行语句，执行完循环体后执行更新表达式（通常用于更新循环变量的值），然后再次判断条件表达式的值，如此循环往复，直到条件表达式的值为 “假” 时，循环结束。
我们可以将上面的 while 循环示例改写成等价的 for 循环形式：
for (int i = 1; i <= 5; i++) {
cout << i << " ";
}
3. 二者相互转换的一般性原理
从本质上来说，while 循环中的条件判断部分可以对应到 for 循环中的条件表达式；while 循环中在循环体之前用于初始化相关变量等操作，可以作为 for 循环的初始化表达式来体现；而 while 循环里在每次循环体执行完后用于更新变量等的语句，可以放在 for 循环的更新表达式位置。
也就是说，只要分析清楚 while 循环里初始化、条件判断以及变量更新这几个关键环节，都可以按照上述对应关系将其改写成结构和功能等价的 for 循环形式，反之亦然，任何一个 for 循环也可以改写成等价的 while 循环。
所以，“任何一个 while 循环都可以转化为等价的 for 循环” 这种说法是正确的，答案为 “√”。
三、编程题（每题25分，共50分）
1、小杨做题
【问题描述】
为了准备考试，杨每天都要做题。第 1 天，杨做了a道题；第 2 天，杨做了b道题；从第 3 天起，小杨每天做的题数量是前两天的总和。
此外，小杨还规定，当某天做了于或等于m题时，接下来的所有日子，他就再也不做题了。
请问，到了第N天，杨总共做了多少题呢？
【输入描述】
总共 4 行。第一行一个整数a ，第二行一个整数b ，第三行一个整数，第四个整数N。
【输出描述】
一行一个整数，表示小杨N天里总共做了多少题目。
【样例输入 1】
1
2
10
5
【样例输出 1】
19
【样例输入 2】
1
1
5
8
【样例输出 2】
12
【题目大意】
小杨为准备考试每天做题，开始第一天做了 a 道题，第二天做了 b 道题，从第三天起每天做的题量是前两天做题数量之和，并且规定当某天做的题数量大于或等于 m 道时，后续日子就不再做题了。现在给定 a、b、m 和天数 N 的值，要求计算出到第 N 天为止小杨总共做的题目数量。
【考纲知识点】
递推（属于四级考纲知识点范畴，本题考查利用递推思想根据题目给定的规则来计算每天做题数量以及累计做题总量的情况），同时涉及到基本的输入输出语句（一级考纲知识点，用于按照题目要求获取输入数据以及输出最终结果）、变量的定义与使用（一级考纲知识点，用于存储相关数据如每天做题数、天数、做题总量等）、控制语句结构（一级考纲知识点，可利用循环语句来实现按天数依次计算做题情况等操作）。
【解题思路】
1.数据读取：
首先，使用输入语句按照题目要求依次读取 a（第一天做题数量）、b（第二天做题数量）、m（规定的停止做题的界限值）和 N（总天数）这四个整数类型的值。
2.初始化相关变量：
定义一个变量 sum 用来累加小杨做题的总数，初始值设为 a + b，因为前两日做题数量已经明确为 a 和 b，先把这两天的数量累加到总和里。
定义两个变量，比如 prev1 用来记录前两天中的前一天做题数量（初始值设为 a），prev2 用来记录前两天中的后一天做题数量（初始值设为 b），方便后续递推计算每天的做题数量。
定义一个计数器变量 day 用于记录当前天数，初始值设为 2，表示已经处理完前两天的情况了，从第三天开始计算。
3.利用递推和循环进行计算：
使用 while 循环（也可以用 for 循环，这里以 while 为例），循环条件为 day < N 且当前做题数量小于 m ，表示在天数未达到指定的 N 天并且还没达到停止做题的界限时继续循环计算。
在循环体内部：
计算当天的做题数量，根据题意，当天做题数量等于前两日做题数量之和，即 int cur = prev1 + prev2; 。
更新做题总数 sum，将当天做题数量累加到 sum 中，即 sum += cur; 。
更新用于递推的前两日做题数量记录变量，让 prev1 等于 prev2，prev2 等于当前新计算出的当天做题数量 cur，即 prev1 = prev2; prev2 = cur; 。
天数计数器 day 加 1，表示进入下一天，即 day++; 。
4.输出结果：
使用输出语句输出最终累加得到的做题总数 sum 的值，这个值就是小杨在 N 天里总共做的题目数量。
【参考程序】
#include <iostream>
using namespace std;
int main() {
int a, b, m, N;
cin >> a; // 读取第一天做题数量
cin >> b; // 读取第二天做题数量
cin >> m; // 读取停止做题的界限值
cin >> N; // 读取总天数
int sum = a + b; // 先累加前两日做题数量
int prev1 = a; // 记录前两天中的前一天做题数量
int prev2 = b; // 记录前两天中的后一天做题数量
int day = 2; // 当前天数，从第三天开始计算
while (day < N && prev2 < m) {
int cur = prev1 + prev2; // 计算当天做题数量
sum += cur; // 累加当天做题数量到总和
prev1 = prev2;
prev2 = cur;
day++;
}
cout << sum << endl; // 输出做题总数
return 0;
}
2、小杨的 H 字矩阵
【问题描述】
小杨想要构造一个N✕N的 H 字矩阵（N为奇数），具体来说，这个矩阵共有N行，每行N个字符，其中最左列、最右列都是 | ，而中间一行（即第（N+1）/2行）的第2~N-1个字符都是 - ，其余所有字符都是半角小写字母a 。例如，一个N=5的H 字矩阵如下：
请你帮小杨根据给定的 打印出对应的“H 字矩阵”。
【输入描述】
一行一个整数N （5≤N≤49，保证N为奇数）。
【输出描述】
输出对应的“H 字矩阵”。
【样例输入 1】
5
【样例输出 1】
|aaa|
|aaa|
|---|
|aaa|
|aaa|
【样例输入 2】
7
【样例输出 2】
|aaaaa|
|aaaaa|
|aaaaa|
|-----|
|aaaaa|
|aaaaa|
|aaaaa|
【题目大意】
小杨想要构造一个特定的 N×N 大小的 H 字矩阵（规定 N 为奇数），矩阵每行有 N 个字符，其构造规则是最左列和最右列字符都为 |，中间一行（也就是第 (N + 1) / 2 行）的第 2 到 N - 1 个字符都是 -，除此之外的其他所有位置字符都是半角小写字母 a，需要根据输入给定的 N 值输出对应的 H 字矩阵。
【考纲知识点】
控制语句结构（一级考纲知识点，重点利用循环语句，像 for 循环来实现按行、按列遍历矩阵并填充相应字符，构建出符合要求的 H 字矩阵），基础数据类型（一级考纲知识点，涉及到整型用于存储矩阵的行数 N 以及在循环中作为计数变量等，还有字符型用于构建矩阵中的字符元素），输入输出语句（一级考纲知识点，按照题目要求读取输入的 N 值，并输出构造好的矩阵内容）。
【解题思路】
1.数据读取：
使用输入语句读取输入的整数 N（满足 5 ≤ N ≤ 49 且为奇数的要求），这个 N 值确定了要构造的 H 字矩阵的行数和列数。
2.构建矩阵：
使用嵌套的 for 循环结构来构建矩阵，外层 for 循环用于控制行数，循环变量设为 i，从 0 开始到 N - 1，表示逐行处理矩阵。
对于每一行（也就是外层循环的每次迭代），再使用内层 for 循环来控制列数，循环变量设为 j，同样从 0 开始到 N - 1，表示逐列处理当前行的元素。
在嵌套的 for 循环内部（也就是处理每个矩阵元素时）：
首先判断当前位置是否是最左列（即 j == 0 ）或者最右列（即 j == N - 1 ），如果是这两种情况之一，那么将当前矩阵元素赋值为 | 字符。
接着判断当前行是否是中间行（即 i == (N + 1) / 2 - 1 ，因为数组下标从 0 开始，所以要减 1 来对应实际的行号），并且当前列不是最左列也不是最右列（即 1 <= j && j <= N - 2 ），如果满足这个条件，那么将当前矩阵元素赋值为 - 字符。
如果以上两个条件都不满足，也就是其他位置的元素，将其赋值为 a 字符。
3.输出矩阵：
在完成整个矩阵的构建后，再使用嵌套的 for 循环来输出矩阵，外层循环控制行数，内层循环控制列数，在内层循环中输出每个元素，并且在每一行的元素都输出完后，输出一个换行符 \n，使得矩阵能够按照正确的格式输出呈现。
【参考程序】
#include <iostream>
using namespace std;
int main() {
int N;
cin >> N; // 读取矩阵的行数（也是列数）N
char matrix[N][N]; // 定义二维字符数组来表示矩阵
// 构建矩阵
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
if (j == 0 || j == N - 1) {
matrix[i][j] = '|';
} else if (i == (N + 1) / 2 - 1 && 1 <= j && j <= N - 2) {
matrix[i][j] = '-';
} else {
matrix[i][j] = 'a';
}
}
}
// 输出矩阵
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
cout << matrix[i][j];
}
cout << endl;
}
return 0;
}
标签：语句,知识点,12,真题,int,C++,循环,考纲 From： https://blog.csdn.net/m0_56456270/article/details/144187014