GESP C++一级真题解析：内存、变量与循环考点

简介：这份2023年9月GESP C++一级真题文档面向准备青少年编程等级考试、信奥赛入门及C++初学的考生与辅导教师，可用于考前自测、课堂练习和知识点查漏补缺。文档完整收录当次认证试卷，包含单选题、判断题和两道编程题，涉及内存与存储设备、变量命名规则、逻辑与算术运算符、输出格式、条件表达式、循环与因数求解、数字拆分、类型转换、字符运算等一级核心考点；编程题的“买文具”和“小明的幸运数”可用于训练输入输出、条件判断与循环枚举。文档以常见题型组织，便于按知识点逐项核对，也适合教师拆分为课堂小测或课后练习。压缩包共1个docx文件，大小约147KB，轻量易取，方便打印或在线批注。已有903人浏览学习，适合作为阶段复习与真题演练材料，帮助读者熟悉题型分布、把握分值结构，并对照解析梳理易错概念。

1. 从一道「内存算哪种设备」的题说起：GESP C++ 一级在考什么

有个孩子拿着 2023 年 9 月那份卷子来问，第一题就把他难住了：我们通常说的「内存」属于计算机中的哪一类设备。他盯着「输出设备、输入设备、存储设备、打印设备」四个选项发愣，因为在他印象里内存条就是插在主板上的一个零件，怎么看都不像「设备」。这道两分的小题，恰好暴露了 GESP C++ 一级考试的基本取向——它不急着让人写出多漂亮的程序，而是先确认学习者对计算机常识和 C++ 语法有没有一个不漏的框架。用一句大白话说，GESP C++ 一级就是一套给零基础的人准备的编程入门体检，用选择、判断、编程三种题型，把「变量能不能这么起名」「表达式先算哪一步」「循环能不能停下来」这些最底层的东西挨个过一遍。搞懂它的出题逻辑，比多背几道答案有用得多。

2. 三十、二十、五十：一级试卷的分值为什么这么切

把整张卷子摊开看，结构干净得有点意外：15 道单选，每题 2 分，共 30 分；10 道判断，每题 2 分，共 20 分；2 道编程，每题 25 分，共 50 分。这个配比不是随手拍的，它对应的是三种完全不同的能力：认得出、辨得清、写得出。

认得出，指的是给你一段代码或者一个表达式，你能说出它大概在干什么；辨得清，指的是面对一句读起来很像正确的话，你能察觉里面藏着的那个错；写得出，指的是从零开始把输入读进来、把逻辑跑一遍、把结果按格式吐出去。三级台阶，一级比一级难，一级比一级接近真实的编程状态。

2.1 三十分的单选题：先把覆盖面铺开

选择题一共十五道，内容像扇形一样铺开。第一题是计算机常识，问内存属于哪类设备；第二题考变量命名，四个选项里藏着一个带空格的red star；第三题直接甩一个表达式2 - 1 && 2 % 10让你求值；再往后是「这段代码执行后输出什么」「下面哪个语句不符合 C++ 语法」这类需要真的在脑子里跑一遍的题。

为什么用选择题而不是填空？因为对刚入门的人来说，从无到有地构造一个正确的表达式太难，但从四个候选里认出哪个是错的要容易得多。选择题本质上考的是「识别」，而识别恰恰是初学阶段最该训练的能力。出题人也很懂新手会怎么错——他把最常见的错误做法直接做成选项摆在你面前，你心里那个「好像应该是这样吧」的念头，就是他要钓的东西。

举个具体的例子。卷子里有一道题给出int类型的 a、b、c，问下面哪条语句不符合 C++ 语法，其中一个选项是b = c % 2.5;。很多人扫一眼就滑过去了，觉得取余嘛，小数也能取。但%这个运算符从一开始就只认整数，右边挂个 2.5，编译器直接不认。这种题不考你会不会写，考的是你有没有真的被编译器报错过。

还有一类是填空题，把一段求因数的循环挖掉一行，让你从i < n; i + 1、i < n + 1; i++这样的组合里挑。四个选项的区别无非是三件事：边界取不取到 n、步进写i++还是i+1、终止条件用<还是<=。看起来都是细枝末节，实际每一处都能让程序要么漏掉最后一个因数，要么原地转圈转到天亮。

单选题的 30 分就是这样一分一分堆出来的：计算机常识两三分，语法规则五六分，表达式与代码输出七八分，边界与填空占掉剩下的。它像一张网，网眼不算密，但该盖住的地方都盖住了。

2.2 二十分的判断题：专挑「读起来挺对」的直觉

十道判断题，每题 2 分，很多人觉得这是送分题，结果对完答案发现送出去的是自己。这类题的设计思路非常统一：把一句似是而非的话摆在面前，让它读起来顺口、听起来合理，然后等着你点头。

比如「cout不可以作为变量名，因为它是 C++ 的关键字」这句话，几乎所有人都觉得对。cout天天用，怎么会不是关键字呢？可它真不是，它是标准库里提前定义好的一个对象，只是名字太熟，熟到像语法的一部分。再比如「('1' + '1')的值为'2'」，字符加字符，听起来结果还是字符，很顺。实际上两个字符先被提升成整数，'1' 的编码是 49，加起来是 98，跟字符'2'一点关系都没有。

判断题里还有一类是「误解某个结构的安全性」。像「do-while循环不可能导致死循环，但while有可能」——这句话错得很有迷惑性，因为 do-while 至少执行一次这个特点容易让人产生「它更安全」的错觉。可只要循环条件恒为真，do-while 照样能转到程序被强制结束。判断一个循环会不会停，看的是条件什么时候变成假，跟先判断还是后判断没关系。

再有一类是「把常识当成必然」。判断题开头混进了两道计算机文化常识：早期机器内存小，会把汉字字库固化在只读存储器的扩展卡上插进主板；国产超级计算机曾多次在全球排行榜上名列前茅。这类题不考编程，考的是你有没有把课本上那些「顺带一提」的内容当回事。很多人复习时把这种段落一眼扫过，考场上就只能靠感觉掷骰子。

2.3 五十分的编程题：为什么它要占掉一半

两道编程题各 25 分，加起来正好一半。这个权重传递的信息很明确：认得出和辨得清只是过程，写得出才是目的。

2023 年 9 月这两道题选得很典型。第一道「买文具」：签字笔 2 元一支要 X 支，记事本 5 元一本要 Y 本，直尺 3 元一把要 Z 把，手里有 Q 元，问够不够买，够就输出 Yes 和剩余的钱，不够就输出 No 和差多少。第二道「k 幸运数」：个位数为 k 的正整数、以及 k 的所有倍数，都叫 k 幸运数，问 L 到 R 之间所有幸运数的和。

这两道题把一级的全部家当都用上了。买文具考的是读入四个数、做一次乘加、一次比较、按两种情况输出两行，中间不需要任何循环；幸运数考的是从 L 遍历到 R、每一步判断两个条件、满足就累加，是标准的单层循环加条件判断。顺序、分支、循环，三种基本结构各就各位，多一个都不用。

// 买文具：读四个数，算总价，分两种情况输出 #include <iostream> using namespace std; int main() { int x, y, z, q; cin >> x >> y >> z >> q; // 依次读入笔、本、尺的数量和手里的钱 int cost = 2 * x + 5 * y + 3 * z; // 三种单价直接写死，来自题目描述 if (cost <= q) { cout << "Yes" << endl; cout << q - cost << endl; // 够了，输出剩余金额 } else { cout << "No" << endl; cout << cost - q << endl; // 不够，输出还差多少 } return 0; }

这段代码里每个变量都对应题目里的一句话，没有多余的角色。endl负责换行，因为题目明确要求输出两行；Yes和No的首字母必须大写，写错一个字母这道题的分数就归零。这类「逻辑全对但格式翻车」的情况在一级里特别常见，编程题的评分程序不认人情，它只认字符。

// k 幸运数：两个条件用“或”连起来，同一次循环里判断完 #include <iostream> using namespace std; int main() { int k, l, r, sum = 0; cin >> k >> l >> r; for (int i = l; i <= r; ++i) { // 个位数是 k，或者能被 k 整除，满足其一就算幸运数 if (i % 10 == k || i % k == 0) { sum += i; } } cout << sum << endl; return 0; }

这段的坑埋在条件里。题目给的例子说得很清楚：7 既是 7 的倍数，个位又是 7，但它只算一次。如果有人图省事，写两个循环分别累加「个位为 k 的数」和「k 的倍数」，7 会被加两遍，样例直接对不上。两个条件必须用||并在同一次判断里完成，这是「只算一次」在代码里的具体写法。l和r都是闭区间，所以循环条件是i <= r而不是i < r，边界少跑一个数，结果就少一截。

再补一个容易忽略的细节：遍历的上限是 1000，sum累加出来的最大值大概在几万到十几万的量级，int完全装得下，不需要开long long。一级不会在数据范围上做文章，它要的是你把逻辑写对，而不是跟溢出斗智斗勇。

3. 变量、表达式与循环：一级反复考的三件底层事

把整张卷子的题目按知识点归类，会发现它们高度集中在三个地方：怎么给东西起名字、怎么让计算机算出一个值、怎么让一段代码重复执行。这三件事撑起了入门阶段几乎所有的题目，剩下的都是它们的变体。

3.1 变量命名：那个空格为什么是硬伤

C++ 对变量名的要求分两层。硬性的一层是编译器不认就报错：不能有空格、不能以数字开头、不能是语言里已经占用的关键字、只能由字母数字下划线组成。软性的一层是可读性：名字最好能看出装的是什么。

red star这个选项错在最硬的那条上。中间那个空格在编译器眼里不是名字的一部分，而是两个词的分隔符，它会把red当成一个标识符，后面跟的star就变成一个没有运算符连接的孤立单词，语法当场崩掉。这不是风格问题，是结构问题。同样是这四个字母，写成redStar、RedStar、red_star都能过，只有中间留空的不行。

// 三种合法写法，风格不同但都能编译通过 int redStar = 1; // 小驼峰，变量名最常见 int RedStar = 2; // 大驼峰，C++ 里区分大小写，和上面是两个不同的变量 int red_star = 3; // 下划线风格，可读性稳

注意第二行和第一行是两个不同的变量，C++ 严格区分大小写，RedStar和redStar在编译器看来毫无关系。这一点经常被用来出题：给你一个叫sum的变量，再问你Sum是不是同一个，答案是否定的。

命名题里还有一类问「下面哪个不能作变量名」，四个选项里往往有一个是关键字，比如int、for、return。这些词被语言本身征用了，你拿来当名字，编译器就分不清你是要声明变量还是要下指令。判断方法很朴素：这些词你在代码里从来没见过被赋过值，它们永远站在语句的开头。

3.2 表达式怎么算：优先级、短路和逗号

一级的表达式题看着吓人，其实套路就三层。

第一层是算术优先。2 - 1 && 2 % 10这个表达式，先算的永远是-和%，得到1 && 2，再算逻辑与。初学者常犯的错是从左往右一路读过去，把2 - 1和2 % 10的先后顺序搞反，或者把&&当成普通的连接符。

第二层是短路求值。&&左边一旦是假，右边根本不看；||左边一旦是真，右边也直接跳过。这个特性在很多题里是解题关键：如果右边藏着一个会出错的操作，短路能让它压根不执行。反过来，如果题目里右边有个自增或者赋值，你得先判断左边，才知道它到底跑没跑。

第三层是逗号表达式。(b = 3, c = 4, b + c)这种写法，从左到右依次执行，整个括号的值取最后一个逗号后面的结果，也就是 7。它常被塞进赋值语句里，a = (b = 3, c = 4, b + c);执行完，a 是 7，b 是 3，c 是 4，三个变量全被改了。

判断题里那句cout<<(2,3,"23")的输出是「2,3,23」，错就错在没搞懂逗号表达式只交出一个值。括号里三个东西依次求值，最后留下的是字符串"23"，前面的 2 和 3 计算完就被丢掉了，屏幕上只会看到 23。这类题不看穿「逗号只保留最后一个」，怎么想都想不通。

还有一处高频失分点：int(3.14)的结果是 3。浮点数转整数是直接砍掉小数部分，不是四舍五入。3.14 砍完是 3，3.99 砍完还是 3，int(-3.9)砍完是 -3 而不是 -4。这个规则叫截断，它跟数学课上学的取整完全不是一回事。

3.3 循环里的两套固定动作：求因数与拆数字

一级的循环题翻来覆去就两种模型，掌握了这两套，八成的题都能拆开。

第一套是求因数。要找一个正整数 n 的所有因数，就写一个从 1 跑到 n 的循环，每个数都试试能不能整除 n。

// 输出 n 的全部因数，从 1 到 n 本身都要试 for (int i = 1; i <= n; i++) { if (n % i == 0) { cout << i << " "; // 能整除，i 就是一个因数 } }

这里有三处细节全在考点上。起点必须是 1，因为 1 能整除任何正整数；终点必须包含 n 本身，因为 n 除以 n 余 0，它也是自己的因数，所以要么写i <= n，要么写i < n + 1；步进必须写i++，写成i + 1的话循环变量永远原地不动，条件一直成立，程序就卡死在那儿了。三道坎，每一道都能把人拦下来。

第二套是拆数字。给一个正整数，要取它的每一位，用的是一对配合：% 10拿末位，/ 10把末位扔掉。

// 求 n 各位数字的平方和 int sum = 0; while (n > 0) { int digit = n % 10; // 取出当前最低位 sum += digit * digit; // 平方后累加 n /= 10; // 去掉最低位，进入下一轮 }

拿 1234 走一遍：1234 % 10得 4，平方加 16，然后1234 / 10变成 123；下一轮拿 3，加 9，变成 12；再拿 2，加 4，变成 1；最后拿 1，加 1，变成 0，循环结束。四步走完，平方和是 30。这段代码里n被反复改写，所以如果后面还要用原来的数，得提前存一份备份，这个坑在一级里偶尔也会埋。

两套动作的共同点是都依赖「取模」和「循环变量怎么变」。一级不考复杂的算法，它把这两套动作反复变形：求因数和、求奇数个数、判断质数、数位拆分、回文判断，都是同一根骨头上长出来的肉。

4. 五处最容易翻车的误区：一级考场上似是而非的直觉

一级的丢分，八成不是不会，而是「以为会」。下面这五处是历年最容易踩的地方，每一条都值得单独拎出来掰扯。

4.1 误区一：以为 cout 是关键字

容易混的点在于，cout出现频率太高，几乎每段代码开头都有它，很多人默认它和int、for一样是语言自带的核心词。

会混是因为使用频率骗了人。cout是标准库在头文件里提前声明好的一个对象，属于「别人给你准备好的工具」，而不是语言语法的一部分。关键字是语言保留词，你绝对不能拿它当变量名；而cout只是别人起的名字，理论上你可以声明一个自己的cout变量把它遮住，当然实战中没人会这么干。

怎么区分：真关键字是那些你从来不会给它赋值、不会问它等于几的词，int、return、while、if都属于这类。而cout你可以对它做操作、可以往它里面塞东西，它是被使用的对象，不是规则本身。判断题问「cout 是关键字所以不能作变量名」，前半句错，后半句的因果关系也就跟着塌了。

4.2 误区二：以为字符相加还是字符

容易混的点在于'1' + '1'这个写法，两边都是带单引号的字符，直觉上结果应该还是字符。

会混是因为把字符当成了数字符号本身。计算机里的字符本质上是编码表上的一个编号，'1'的编号是 49，'A'是 65，'a'是 97。两个字符相加，编译器先把它们提升成整数再算，49 加 49 得 98，结果是一个整数，不是字符'2'。要想得到'2'，得写'1' + 1，因为'2'的编号正好比'1'大 1。

怎么区分：看到字符参与算术运算，先在心里把它翻译成数字。字符减字符能得到两个字符编码的差值，这个用法在大小写转换里很常见；字符加整数能得到偏移后的字符；字符加字符则几乎总是错的，因为它只是两个编码相加，跟拼接毫无关系。

4.3 误区三：以为 do-while 不会死循环

容易混的点在于 do-while「先执行后判断」的结构，让人误以为它天然有一层保护。

会混是因为「至少执行一次」听起来像是「总有个头」。但循环能不能停，取决于条件什么时候变假，跟先判断还是后判断没有半点关系。do { ... } while (true);这行代码照样能转到程序被强制结束。反过来说，while也不一定危险，只要循环体里有机会改变条件，它自然会退出。

怎么区分：判断死循环只看一件事——循环条件依赖的变量，在循环体里有没有被改动、改动的方向对不对。如果那个变量从头到尾没变过，条件就永远停在初始状态，无论 while 还是 do-while 都是死路。另外continue也值得留神，如果它出现在修改变量之前，后面的语句被跳过，变量同样不会变，循环照样停不下来。

4.4 误区四：以为取模能算小数

容易混的点是%这个符号在数学里写作「取余数」，而余数这个概念在小学就学过，小数除法的余数也有人算过。

会混是因为数学和编程对「余数」的定义不完全一样。C++ 的%只接受整数操作数，两边只要有一个是浮点数，编译器立刻报错。c % 2.5这种写法通不过编译，不是结果不对的问题，是压根不让你写。

怎么区分：记住一条硬规则——看到%，两边必须是整型。要处理小数取余，得用fmod这类库函数，而一级根本不会考到那儿。选择题里凡是出现「小数参与取模」的选项，基本可以直接划掉。

4.5 误区五：以为类型转换会四舍五入

容易混的点在于int(3.14)得到 3，int(3.99)也得到 3，这两件事放在一起看，很像「取整」在日常语言里的意思。

会混是因为中文里的「取整」既可以指四舍五入，也可以指向下取整，而 C++ 在这里选的是最简单粗暴的一种：把小数部分直接砍掉。它不看你离下一个整数有多近，3.99 和 3.01 在它眼里一样，都是 3。负数更反直觉，int(-3.9)得到的是 -3，因为砍掉小数部分之后，-3.9 剩下的是 -3，比它本身大。

怎么区分：把「截断」和「取整」分开记。截断是往零的方向砍，四舍五入是往最近的整数靠，向下取整是往负无穷方向靠，三者在正数上有时碰巧一样，在负数上立刻分家。要四舍五入得自己写int(x + 0.5)，要向下取整有专门的函数，一级只需要认清截断这一种行为就够了。

5. 等级认证还是竞赛：GESP 一级和信奥赛入门组差在哪

不少人把 GESP 和信奥赛当成同一件事的两个名字，复习的时候就拿竞赛题去刷，刷得云里雾里还以为是自己的问题。这两者从目标到题型都不一样，混着用只会两头不讨好。

5.1 两套不同的尺子：一个量「够不够格」，一个量「排第几」

等级认证的逻辑是达标。它事先画好一条线，告诉你这个级别该会什么，题目就围着这条线出，难度平稳，不刻意制造区分度。你只要把该会的都写对了，就能过。一级的编程题给的是「买文具」和「幸运数」这种生活化、边界清晰、不需要巧妙想法的题目，写出来就是分。

竞赛的逻辑是选拔。它要在同一批人里分出高下，题目必须有梯度，简单题人人会，难题能筛掉绝大多数人，中间还夹着一批需要动脑子的题。同一批知识点，竞赛会把它包装成需要观察规律、需要优化、需要处理大规模数据的形式。

打个不太严谨的比方：等级认证像驾照的科目一，考的是你知不知道红灯停绿灯行；竞赛像一场拉力赛，考的是你能不能在复杂路况下比别人快。会开车是参赛的前提，但科目一考满分不代表能跑完拉力赛。

5.2 一级的知识边界画在哪条线上

一级的范围窄得有点出人意料。够用的东西包括：变量声明与命名规则、cin和cout的基本用法、整数与浮点的算术运算、关系与逻辑运算及其优先级、if分支、for和while循环、%取模和整数除法。这些凑在一起，就够写出买文具和幸运数了。

不在范围内的东西同样值得记住：数组、函数、指针、结构体、类、字符串处理函数、递归、排序算法。这些在后面级别才会逐个登场，一级的卷子里不会故意为难你，也不会因为你不会而扣分。

提示：具体每一级的考纲以官方发布的大纲为准，上面这张表只对应 2023 年 9 月这份一级卷子呈现出来的面貌。

5.3 从一级往上，阶梯是怎么接的

一级解决的是「能不能让计算机按顺序做几件事」。往上一级，题目会开始要求你处理一批数据而不是一个数，循环会嵌套，判断会变复杂，代码量从十几行涨到几十行。再往上，算法的味道就出来了：怎么更快、怎么更省、怎么在数据变大的时候还跑得动。

这条路径和竞赛路径会有交叉，但不是同一条路。走等级认证的人，节奏是被级别切好的，一级一关，每关有明确的考点清单；走竞赛路线的人，节奏是被赛题和排名推着走的，可能十岁就学到别人初中才碰的内容，也可能在某个知识点上卡很久。

对刚入门的人来说，先走完一级这件事的价值在于：它给了一个不吓人的起点。你不需要会写漂亮的算法，只需要证明自己把最基础的语法和逻辑串起来了。这个证明本身不厉害，但它能让你知道自己站在哪。

6. 什么时候该刷这份真题：一份卷子的适用边界

这份 2023 年 9 月的卷子，适合的人其实很具体。

适合的是这样几种：刚学完 C++ 的输入输出、分支、循环，想确认自己有没有漏掉基本语法的人；准备考一级，想知道「考到什么程度算够」的人；教别人入门，需要一份现成的题目来定位学生薄弱环节的人；以及学了一段时间但一直靠抄代码过关，想找找自己到底哪块是空的的人。对这几类人，做完一遍再逐题对错因，比看十篇经验帖都有用。

不适合的也很具体。还没写过for循环的人，做这套卷子只会收获挫败，因为编程题的 50 分你一分都拿不到，而选择题里大量的代码输出题也需要你能在脑子里跑一遍循环。已经学完数组和函数、在准备更高级别的人，这份卷子的信息量对你来说太低，除了查漏补缺没什么别的价值。还有一种情况最可惜：把这份卷子当成背答案的材料，做完一遍记住选项就完了，下次换个数字还是不会。

真正容易翻车的地方不在难题上，在格式和边界上。有人编程题思路全对，Yes写成了YES，零分；有人求因数写i < n，漏掉了 n 自己，样例过不了；有人幸运数分两轮累加，7 被算了两次，答案差出一个数。这些都不是理解问题，是手感和习惯问题，只有真的自己敲一遍、被样例打回来几次，才会长记性。

我自己在这类卷子上吃过的最大的亏，是第一次带人做的时候太相信「看懂了就等于会了」。当时觉得选择题扫一眼就知道答案，编程题思路也讲得头头是道，就没让人动手写。结果真上手，cin的顺序读错了、endl忘了加、循环边界差一，一道 25 分的题只拿到一半。从那以后我每次带人过这种卷子，都强制走一遍「先自己写、再对样例、最后才看解析」的流程，宁可慢，也不让「好像会了」蒙混过去。你要是也打算用这份材料，不妨按这个顺序来一遍，不用追求快。希望帮到你。

本文还有配套的精品资源，点击获取