阅读下面的程序：
01#include <iostream> 02using namespace std; 03 04int main() { 05 cout << "Hello"; 06 return 0; 07}
return 0; 的作用是（ ）。
考点：main 函数与返回值（A1）。
（A1）考点：main 函数的 return 0; 是向操作系统报告程序正常结束，返回码约定 0 表示成功、非 0 表示异常。
解析：return 0; 的 0 不是输出内容——程序输出的是前面的 Hello。返回值交给启动程序的系统（如评测系统据它判断程序是否正常退出）。
排除法：选"让程序输出一个 0"的人把返回值当成了输出内容（返回值不上屏）；选"关闭所有打开的文件"的人混淆了返回值与 fclose；选"必需的语法否则无法编译"的人不知道 main 里可以省略（编译器会补默认的 return 0）。
下面的程序使用 sqrt 计算平方根，但没有写任何 #include：
01int main() { 02 double x = sqrt(16); 03 return 0; 04}
编译这个程序，结果是（ ）。
考点：头文件（A2）。
（A2）考点：sqrt 声明在 <cmath> 里，不包含头文件直接使用会报编译错误（标识符未声明）。
解析：sqrt(16) 要用 <cmath> 的声明，代码没有任何 #include，编译器看到 sqrt 不认识，直接编译失败。
排除法：选"正常运行值为 4"的人以为数学函数不用头文件就能用；选"运行时错误"的人混淆了编译期与运行期（还没到运行就失败了）；选"编译警告但可以运行"的人把老 C 的"隐式函数声明"宽容规则误套到 C++。
下面的程序可以正确输出 3：
01#include <iostream> 02int main() { 03 std::cout << 3; 04 return 0; 05}
其中 std::cout 里的 std 表示（ ）。
考点：命名空间（A3）。
（A3）考点：std 是命名空间，标准库里的 cout、cin、string 等都定义在里面；std::cout 表示"std 命名空间里的 cout"。
解析：命名空间用来防止名字冲突（比如你自己也定义了一个 cout 时不打架）。using namespace std; 就是把 std 里的名字都提出来直接用。
排除法：选"一个宏"的人把 std 当成了文本替换；选"一个类"的人混淆了类与命名空间（cout 才是对象）；选"一个函数"的人概念错位。
阅读下面的程序：
01int x = 10; 02// x = 20; 03cout << x;
程序的输出是（ ）。
考点：注释不参与执行（A4）。
（A4）考点：// 注释到行尾的内容编译器完全忽略——注释不参与执行。
解析：x = 10; 执行后 x 是 10；第二行的 x = 20; 在 // 后面，被当作注释忽略，x 仍是 10。
排除法：选"输出 0"的人把"未执行"理解成了"被清零"；选"编译错误"的人不知道注释是合法语法；选"输出 20"的人以为注释也会执行。
阅读下面的程序：
#define N 10 + 5 cout << N * 2;
程序的输出是（ ）。
考点：宏定义的括号陷阱（A5）。
（A5）考点：#define 是纯文本替换——N * 2 展开成 10 + 5 * 2，按优先级先算乘法得 20，不是 30。
解析：#define N 10 + 5 后，代码里每个 N 被原样替换成 10 + 5，N * 2 变成 10 + 5 * 2 = 20。宏定义的值若参与运算必须整体加括号：#define N (10 + 5)。
排除法：选 30 的人以为宏替换后当成整体 ；选 15 的人只算了 10 + 5；选 50 的人无运算依据。
在命令行中，把 a.cpp 编译成名为 a 的可执行文件，正确的命令是（ ）。
考点：g++ 编译命令（A6）。
（A6）考点：g++ a.cpp -o a 表示"把 a.cpp 编译链接成名为 a 的可执行文件"——-o 后面跟输出文件名。
解析：g++ 一次完成编译+链接，-o a 指定输出文件名为 a。
排除法：选带 -c 的人那表示只编译不链接（生成 .o 目标文件，不会出可执行文件）；选 ./a a.cpp 的人那是运行可执行文件的写法；选把输入输出文件名对调的人顺序写反了。
下列标识符中，合法的是（ ）。
考点：标识符规则（A7）。
（A7）考点：标识符只能由字母、数字、下划线组成，且不能以数字开头，不能是关键字。
解析：_abc 以字母开头、只含字母数字下划线，合法。
排除法：选 int 的人那是关键字，不能用作变量名；选 a-b 的人含连字符（会被当成减号）；选 2ab 的人以数字开头。
阅读下面的程序：
01int x = 2147483647; 02x = x + 1;
执行后 x 的值是（ ）。
考点：int 溢出（B1）。
（B1）考点：int 是 32 位补码，最大值 2147483647 加 1 会溢出回卷成最小值 -2147483648（不是报错）。
解析：2147483647 是 0111...1111（31 个 1），加 1 变成 1000...0000，按补码解释就是 -2147483648。溢出是静默的，程序不会报错。
排除法：选 2147483648 的人以为 int 能装下它（32 位上限是 2147483647）；选 2147483647 的人以为加 1 没变化；选"程序报错退出"的人以为溢出会报错（C++ 不检查整数溢出）。
阅读下面的程序：
01int x = 100000 * 100000; // 本意是算 10^10 02long long y = 1LL * 100000 * 100000;
执行后 x 和 y 的值分别是（ ）。
考点：long long 与中间溢出（B2）。
（B2）考点：100000 * 100000 两个 int 相乘，乘法在 int 范围内先计算，溢出后才赋给 long long——所以要先转成 long long（1LL * ...）。
解析：int x = 100000 * 100000; 中间结果是 ，超出 int 上限，溢出为 1410065408；long long y = 1LL * 100000 * 100000; 中 1LL 把计算提升到 long long，结果正确为 10000000000。
排除法：选"x、y 都是 10000000000"的人以为中间溢出不会发生；选"x 正确 y 溢出"的人把方向弄反；选"都溢出"的人以为 long long 的版本也会溢出。
阅读下面的程序：
01double x = 0.1 + 0.2; 02if (x == 0.3) 03 cout << "equal"; 04else 05 cout << "not equal";
程序的输出是（ ）。
考点：浮点精度（B3）。
（B3）考点：0.1 和 0.2 在二进制里是无限循环小数，0.1 + 0.2 的结果是 0.30000000000000004，不等于 0.3。
解析：浮点数用二进制近似存储，比较浮点数相等应该用"差小于一个极小值"的方式（fabs(a - b) < 1e-9），而不是 ==。
排除法：选 "equal" 的人按十进制直觉回答（"0.1+0.2 当然等于 0.3"正是这道题的坑）；选"运行时错误"或"编译错误"的人不知道代码完全合法。
阅读下面的程序：
01char c = 65; 02cout << c;
程序的输出是（ ）。
考点：char 与 ASCII（B4）。
（B4）考点：char 存的是整数（ASCII 码），65 对应字符 'A'——用 cout 输出 char 变量时输出字符本身而不是数字。
解析：char c = 65; 把整数 65 存入 c，cout << c 按字符输出，即 A。
排除法：选 65 的人以为输出数字（那是 cout << (int)c 的效果）；选 65.0 的人混淆了整数与浮点输出形式；选"编译错误"的人不知道这是合法的。
阅读下面的程序：
01bool b = 5; 02cout << b;
程序的输出是（ ）。
考点：bool 转换（B5）。
（B5）考点：bool 只能存 0 或 1——非零整数赋给 bool 变成 1（true），cout << bool 输出数字 1（不是 true）。
解析：bool b = 5; 先把 5 转成 true（即 1）存储；cout << b 默认按整数形式输出 bool，即 1。想输出 true/false 要用 boolalpha。
排除法：选 5 的人以为 bool 能存下 5；选 true 的人以为直接输出单词 true；选 0 的人把"非零为真"记反了。
阅读下面的程序：
01const int N = 100; 02N = 200; 03cout << N;
编译并运行这个程序，结果是（ ）。
考点：const 常量（B6）。
（B6）考点：const 修饰的变量是常量，修改常量是编译错误——这是编译器在编译期就拦下的错误。
解析：const int N = 100; 声明 N 是常量，N = 200; 试图给常量赋值，编译器直接报错，程序根本不会生成。
排除法：选"输出 200"的人以为常量也能改（那是普通变量）；选"输出 100"的人以为编译器会容忍；选"运行时报错"的人混淆了编译期与运行期。
阅读下面的程序：
01int x; 02cout << x;
关于程序的输出，下列说法正确的是（ ）。
考点：未初始化变量（B7）。
（B7）考点：局部变量不自动初始化，int x; 后 x 的值是内存里残留的垃圾值，读取它是未定义行为。
解析：int x; 只分配空间不赋值，x 的初值不确定——可能是 0，也可能是任意数，每次运行都可能不同。
排除法：选"一定输出某个固定的大数"的人以为垃圾值是固定的（其实是随机的）；选"编译错误"的人不知道这是合法语法；选"一定输出 0"的人把"全局变量自动清零"的规则误套到局部变量。
一个 位无符号整数能表示的最大值，最接近（ ）。
考点：无符号最大值（B8）。
（B8）考点：32 位无符号整数全部 32 位都是数值位，最大值 。真题 2025 年考过此问法。
解析：无符号没有符号位，32 位全用来表示非负数，范围 。对比有符号 int：最高位是符号位，最大只有约 。
排除法：选 的人低估了两个数量级；选 的人用的是有符号 int 的上限；选 的人数字接近但量级算错。
下列选项中，全部属于 C++ 基本数据类型的是（ ）。
考点：基本类型辨析（B9）。
（B9）考点：C++ 基本数据类型是 int、long long、float、double、char、bool 等；string、set 是库类型（类模板），real 根本不存在。真题 2024 年考过此问法。
解析：基本类型是语言内建的；string 属于标准库（<string>），set 属于 STL 容器，都不是基本类型。
排除法：选含 string 的人把常用的字符串当成了基本类型；选含 real 的人那是 Pascal 语言的关键字，C++ 没有；选含 set 的人把 STL 容器当成了基本类型。
阅读下面的程序：
01double y = 7 / 2;
执行后 y 的值是（ ）。
考点：整数除法（C1）。
（C1）考点：7 / 2 两个 int 相除是整数除法，结果截断为 3，再赋给 double 变成 3.0——先算除法、后转类型。
解析：7 / 2 在 int 范围内计算得 3（丢掉了小数部分），赋给 double y 时才转成 3.0。想得到 3.5 必须先把操作数转浮点：7.0 / 2 或 (double)7 / 2。
排除法：选 3.5 的人以为赋值给 double 会自动得到小数；选 3 的人得到了 int 结果但没注意变量是 double（显示 3.0）；选 4 的人是四舍五入的误解（截断是直接丢小数部分）。
阅读下面的程序：
01int x = -7 % 3;
执行后 x 的值是（ ）。
考点：负数取模（C2）。
（C2）考点：C++ 里取模结果的符号跟随被除数——-7 % 3 得 -1（先按正数相除得余 1，再带上被除数的负号）。
解析： 余 ，被除数是 -7，所以结果是 -1。注意 7 % -3 则得 1（符号只看被除数）。
排除法：选 -2 的人把符号记到了除数上；选 1 的人忘了带负号；选 2 的人按"余数总是正数"记。
阅读下面的程序：
01int i = 5; 02int a = i++; 03int b = ++i;
执行后 a 和 b 的值分别是（ ）。
考点：自增自减（C3）。
（C3）考点：i++ 返回加之前的旧值（先取值后加），++i 返回加之后的新值（先加后取值）。
解析：a = i++ 时 i 是 5，a 拿到 5，i 变 6；接着 b = ++i，i 先变 7，b 拿到 7。所以 a=5、b=7。
排除法：选"a=5, b=6"的人把 ++i 当成了"先取后加"；选"a=6, b=6"的人把 i++ 当成了"先加后取"；选"a=6, b=7"的人两处都理解反了。
阅读下面的程序：
01int x = 8; 02x /= 2; 03x += 5;
执行后 x 的值是（ ）。
考点：复合赋值（C4）。
（C4）考点：x /= 2 等价于 x = x / 2（整数除法），复合赋值逐条生效。
解析：；。最终 x 为 9。
排除法：选 13 的人无运算依据；选 4 的人只算了第一步；选 14 的人是"先加后除"的顺序错。
阅读下面的程序：
01int a = 10, b = 20; 02cout << (a > b ? a : b);
程序的输出是（ ）。
考点：三目运算（C5）。
（C5）考点：条件 ? 值1 : 值2 条件为真取前面的值、为假取后面的值——a > b 为假，取 b。
解析： 为假，三目表达式返回冒号后的 b，即 20。
排除法：选 10 的人把真假分支取反了；选 0 或 1 的人把三目结果当成了真假值本身（三目返回的是选中分支的值，不是 0/1）。
阅读下面的程序：
01int x = (1, 2, 3);
执行后 x 的值是（ ）。
考点：逗号表达式（C6）。
（C6）考点：逗号表达式的值是最后一个子表达式的值——(1, 2, 3) 依次求值 1、2、3，整体取 3。
解析：逗号运算符从左到右依次求值，整个表达式的值等于最右边的 3，所以 x = 3。
排除法：选 6 的人把三个数当成了求和；选 1 的人以为取第一个；选"编译错误"的人不知道逗号是合法运算符。
阅读下面的程序：
01int x = 8 / 2 * (2 + 2);
执行后 x 的值是（ ）。
考点：运算优先级与结合性（C7）。
（C7）考点：括号最高、乘除高于加减、同级从左到右——8 / 2 * (2 + 2) 先算括号得 4，再从左到右 。
解析：；然后 8 / 2 * 4 同级从左到右：，。
排除法：选 1 的人把 * 的优先级看得比 / 高，先算了 ；选 4 的人只算了 忘了乘 4；选 8 的人是 与 的拼凑。
阅读下面的程序：
01int a, b; 02cin >> a >> b; 03cout << a << " " << b;
输入 3 5 并回车，程序的输出是（ ）。
考点：cin 连续读入（D1）。
（D1）考点：cin >> a >> b 连续读入，按空白（空格/换行）分隔依次赋给 a、b——输出时中间的空格是 " " 字符串自己加的。
解析：输入 3 5，a 读到 3、b 读到 5；cout << a << " " << b 输出 3 5。
排除法：选 5 3 的人顺序记反；选 3 的人以为只读一个数；选 35 的人以为两个数会被连成 35（cin 按空白分隔，不会拼接）。
阅读下面的程序：
01int a, b, c; 02cin >> a >> b; 03c = 0; 04cin >> c; 05cout << a << " " << b << " " << c;
输入 3 5 7 并回车，程序的输出是（ ）。
考点：cin 多余输入留存（D2）。
（D2）考点：cin 只取需要的部分，多余的输入留在缓冲区，下一次 cin 会接着读。
解析：第一次 cin >> a >> b 读走 3 和 5，7 留在缓冲区；c = 0; 把 c 赋 0；第二次 cin >> c 从缓冲区读到 7，c 变成 7。输出 3 5 7。
排除法：选 3 5 0 的人以为第二次 cin 读不到数据、c 保持 0；选"编译错误"的人不知道代码合法；选 3 5 的人以为只输出前两个数。
阅读下面的程序：
printf("%d %d", 3, 5);
程序的输出是（ ）。
考点：printf 格式串（D3）。
（D3）考点：printf("%d %d", 3, 5) 中格式串里的普通字符原样输出，%d 依次被后面的整数替换。
解析：%d 是整数占位符，两个 %d 对应 3 和 5，中间的空格原样输出，得到 3 5。
排除法：选 35 的人忘了格式串里有空格；选 5 3 的人参数顺序记反；选 %d %d 的人不理解占位符替换。
阅读下面的程序：
01int x; 02scanf("%d", &x);
其中 &x 的作用是（ ）。
考点：scanf 取地址（D4）。
（D4）考点：scanf 要把读到的值写进变量，所以需要变量的地址 &x——不传地址它就无法修改 x。
解析：&x 是"取 x 的地址"，scanf 按这个地址把读入的值写进 x 的内存里。传值的话 scanf 改的是副本，x 不会变。
排除法：选"把 x 的值传给 scanf"的人说反了方向（scanf 是写不是读）；选"对 x 取反"的人把 & 当成了位运算；选"声明 x 是一个引用"的人混淆了取地址与引用声明两种用法。
阅读下面的程序（已包含头文件 <iomanip>）：
cout << fixed << setprecision(2) << 1.0 / 3;
程序的输出是（ ）。
考点：cout 输出精度（D5）。
（D5）考点：fixed << setprecision(2) 表示"固定小数形式、保留 2 位小数"——1.0 / 3 输出 0.33（第三位被舍去）。
解析：fixed 关闭科学计数法、固定小数点位置，setprecision(2) 保留两位小数， 取两位得 0.33。
排除法：选 0.3 的人少保留了一位；选"编译错误"的人不知道只要包含 <iomanip> 就合法（题干已说明）；选 0.333333 的人用的是默认输出（未设精度）。
阅读下面的程序：
printf("%.2f", 3.14159);
程序的输出是（ ）。
考点：printf 小数位（D6）。
（D6）考点：printf("%.2f", 3.14159) 的 .2 表示保留 2 位小数——第 3 位是 1，舍去得 3.14。
解析：%.2f 保留两位小数， 的第三位小数是 1（小于 5），直接舍去得 3.14。
排除法：选 3.15 的人把第三位的 1 错误地当成了进位（只有 ≥5 才进位）；选 3.1 的人只保留了一位；选 3.14159 的人没加 .2 的效果。
阅读下面的程序，其中 a = 1，b = 0：
01int x = 0; 02if (a) 03 if (b) 04 x = 1; 05 else 06 x = 2;
执行后 x 的值是（ ）。
考点：else 就近配对（E1）。
（E1）考点：else 与最近的未配对 if 配对——内层的 else 属于内层 if (b)，不是外层 if (a)。
解析：a=1 进入外层，b=0 时内层 if (b) 为假，执行它的 else 分支，x=2。
排除法：选 0 的人以为 else 与外层 if 配对、外层为真所以不执行 else；选"编译错误"的人不知道缩进不影响配对（只按语法规则配对）；选 1 的人那是 b=1 时的结果。
阅读下面的程序：
switch (2) {
case 1: cout << "A";
case 2: cout << "B";
case 3: cout << "C";
}
程序的输出是（ ）。
考点：switch 贯穿（E2）。
（E2）考点：switch 匹配到 case 2 后，没有 break 会一直往下执行（贯穿）——输出 BC。
解析：switch(2) 跳到 case 2，输出 B；没有 break，继续执行 case 3 输出 C；到这里才结束。
排除法：选 ABC 的人以为从 case 1 开始顺序执行（switch 是跳到匹配的 case）；选 B 的人漏了贯穿；选"编译错误"的人不知道这是合法（虽然有警告）的。
阅读下面的程序：
01int x = 5; 02if (x = 3) 03 cout << "A"; 04else 05 cout << "B";
程序的输出是（ ）。
考点：赋值与判等（E3）。
（E3）考点：x = 3 是赋值不是判等——赋值表达式的值是被赋的值 3（非零为真），所以进入 if 分支输出 A。
解析：x = 3 把 3 赋给 x，整个表达式的值是 3，非零即真，条件成立输出 A。判断相等必须写 x == 3。
排除法：选 B 的人把 = 当成了 == 来理解（这是本题的坑）；选"编译错误"的人不知道 = 在条件里是允许的；选 AB 的人不知道两个分支只会走一个。
阅读下面的程序：
01if ('0') 02 cout << "true"; 03else 04 cout << "false";
程序的输出是（ ）。
考点：字符 0 的真假（E4）。
（E4）考点：'0' 是字符，ASCII 码是 48，非零即为真——字符 0 和数字 0 是两回事。
解析：条件里 '0' 的值是 48，非零，条件为真，输出 true。只有数字 0（或 '\0' 空字符）才表示假。
排除法：选 "false" 的人把字符 '0' 当成了数字 0；选"编译错误"或"运行时报错"的人不知道这是完全合法的表达式。
阅读下面的程序：
01int x = 0; 02if (x != 0 && 10 / x > 2) 03 cout << "A"; 04else 05 cout << "B";
程序的输出是（ ）。
考点：短路求值（E5）。
（E5）考点：&& 的短路求值——左边 x != 0 为假时，右边 10 / x > 2 根本不会执行，所以没有除零错误。
解析：x = 0，x != 0 为假，整个 && 已经确定为假，右边的除零表达式被跳过，程序安全输出 B。
排除法：选 A 的人误判条件为真（x=0 时 x!=0 是假）；选"编译错误"的人不知道这是合法的；选"程序因除零崩溃"的人忽略了短路机制。
阅读下面的程序，其中 score = 90：
01if (score >= 60) 02 cout << "及格"; 03else if (score >= 80) 04 cout << "优秀"; 05else 06 cout << "不及格";
程序的输出是（ ）。
考点：条件顺序陷阱（E6）。
（E6）考点：多分支按书写顺序判断——第一个满足的分支命中后不再看后面的条件；条件顺序错了，更细的分支永远到不了。
解析：score = 90 先命中 score >= 60，输出"及格"；后面的 score >= 80 根本没机会判断。正确顺序应该把"优秀"（更严格的条件）放在前面。
排除法：选"优秀"的人按"符合哪个更贴切"来选（实际按顺序命中）；选"不及格"的人那是 60 以下的结果；选"编译错误"的人不知道代码合法。
与逻辑表达式 a && (b || c) 始终等价的表达式是（ ）。
考点：逻辑等价变形（E7）。
（E7）考点：&& 对 || 的分配律——a && (b || c) = (a && b) || (a && c)。真题 2025 年考过此问法（找不等价的式子）。
解析：若 a 为假，两边都假；若 a 为真，左边取决于 b||c，右边取决于 b 或 c 至少一个真——真值表逐行验证相等。
排除法：选 (a && b) || c 的人丢了 a 对第二项的约束（a 假而 c 真时两者不同）；选 (a || b) && (a || c) 的人那是 a || (b && c) 的分配（方向搞反）；选 !(a || b) && c 的人混入了德摩根律的错用。
阅读下面的程序：
01int cnt = 0; 02for (int i = 1; i <= 10; i += 2) 03 cnt++;
执行后 cnt 的值是（ ）。
考点：for 步长与次数（F1）。
（F1）考点：i += 2 每轮加 2——i 取 1、3、5、7、9 共 5 次循环。
解析：从 1 开始每次加 2，直到超过 10：，共 5 轮。
排除法：选 4 的人漏数了 9；选 6 的人多数了一次（以为 11 也进循环，其实 11 > 10 已停）；选 10 的人把步长当成了 1。
阅读下面的程序：
01int i = 5; 02while (i--) 03 ;
执行后 i 的值是（ ）。
考点：while 自减循环（F2）。
（F2）考点：while (i--) 判断减之前的旧值——i 依次判断 5、4、3、2、1 共 5 轮，退出时 i 已经自减到 -1。
解析：每轮先判断 i 的旧值（非零继续）再自减：5→4→3→2→1→0（判 0 为假退出，退出时 i 减到了 -1）。
排除法：选 0 的人只数到了 0（忘了退出判断那一轮的自减）；选 5 的人以为循环不执行；选 1 的人记成了"先减后判"的结果。
阅读下面的程序：
01int i = 10; 02do { 03 cout << i; 04 i++; 05} while (i < 3);
程序的输出是（ ）。
考点：do-while 至少一次（F3）。
（F3）考点：do-while 先执行后判断——条件 i < 3 虽然一开始就不成立，循环体仍执行一次，输出 10。
解析：i=10 先执行循环体输出 10、i 变 11，再判断 11 < 3 为假退出。与 while 不同，do-while 保证至少执行一次。
排除法：选 101112 的人以为会循环输出多轮（条件一直不成立）；选"编译错误"的人不知道语法合法；选"不输出任何内容"的人把 do-while 当成了 while（先判断）。
阅读下面的程序：
01int s = 0; 02for (int i = 1; i <= 5; i++) { 03 if (i == 3) 04 continue; 05 s += i; 06}
执行后 s 的值是（ ）。
考点：break 与 continue（F4）。
（F4）考点：continue 跳过本轮剩余语句进入下一轮——i=3 时跳过 s += i，其余照常累加。
解析：（3 被 continue 跳过）。若写成 break 则是 后直接结束循环。
排除法：选 10 的人把 continue 当成了 break 的效果；选 7 的人无依据；选 15 的人是全加 （忽略了 continue）。
阅读下面的程序：
01int cnt = 0; 02for (int i = 0; i <= 5; i++) 03 cnt++;
执行后 cnt 的值是（ ）。
考点：循环边界多跑一次（F5）。
（F5）考点：i <= 5 是闭区间——i 取 0、1、2、3、4、5 共 6 次；写成 i < 5 才是 5 次。
解析：从 0 到 5（含两端）一共 6 个数，循环体执行 6 次。边界条件是 <= 还是 < 决定了循环次数，差 1 是最常见的循环 bug。
排除法：选 4 的人漏数了 0 和 5 两端的数；选 5 的人按"0 到 5 共 5 个"的直觉数错；选 7 的人多数了一次。
阅读下面的程序：
01int cnt = 0; 02for (int i = 1; i <= 3; i++) 03 for (int j = 1; j <= i; j++) 04 cnt++;
执行后 cnt 的值是（ ）。
考点：嵌套循环计数（F6）。
（F6）考点：内层循环次数依赖外层变量时，总次数是各轮内层次数之和——。
解析：i=1 时内层 j 跑 1 次，i=2 时跑 2 次，i=3 时跑 3 次，共 次。
排除法：选 3 的人只算了外层次数；选 9 的人按"3×3=9"（内层与外层无关时才是 9）；选 12 的人把 算成了两倍。
阅读下面的程序：
01for (int i = 0; i < 5; i++) 02 ; 03cout << i;
编译这个程序，结果是（ ）。
考点：循环变量作用域（F7）。
（F7）考点：for 里声明的变量只在循环内有效——循环结束后 i 已不存在，外面使用是编译错误。
解析：int i 声明在 for 的小括号里，作用域到循环体结束为止；cout << i; 在循环外，此时 i 未声明，编译报错。
排除法：选"输出 4"或"输出 5"的人以为 i 出了循环还能用（那是把 i 声明在循环外的情况）；选"输出 0"的人同样错。
阅读下面的程序：
01int main() { 02 cout << f(3); 03 return 0; 04} 05 06int f(int x) { 07 return x * x; 08}
编译这个程序，结果是（ ）。
考点：先声明后调用（G1）。
（G1）考点：函数要先声明（或先定义）后使用——main 在 f 的定义之前调用 f，编译器不认识 f，报编译错误。
解析：编译器从上往下读代码，读到 f(3) 时还没见过 f，报"未声明"。解决：把 f 的定义放到 main 前面，或在 main 前加函数声明 int f(int x);。
排除法：选"正常运行输出 9"的人以为编译器会自动往后找定义（它不会）；选"运行时错误"的人混淆了编译期与运行期；选"链接错误"的人那是"声明了但没定义"才会出现的错误。
阅读下面的程序：
01int f(int x) { 02 if (x > 0) 03 return 1; 04}
调用 f(0)，返回值的情况是（ ）。
考点：漏写返回值（G2）。
（G2）考点：有返回值的函数每条路径都必须 return——x <= 0 时没有 return 语句，返回值不确定，属于未定义行为。
解析：f(0) 时 x > 0 为假，整个 if 跳过，函数没有执行任何 return 就结束了——返回什么完全不确定，可能随机返回某个垃圾值。
排除法：选"返回 0"的人以为没 return 就自动返回 0（只有 main 有默认返回 0 的规则）；选"返回 1"的人把 if 分支的返回值当成了全部情况；选"编译错误"的人不知道能通过编译（编译器不一定拦下这种逻辑错误）。
阅读下面的程序：
01void f(int x) { 02 x = 100; 03} 04 05int main() { 06 int a = 5; 07 f(a); 08 cout << a; 09 return 0; 10}
程序的输出是（ ）。
考点：值传递（G3）。
（G3）考点：值传递时形参是实参的副本——函数里改形参 x，外面的实参 a 不受影响，仍输出 5。
解析：f(a) 把 a 的值 5 复制给形参 x，函数里 x = 100 改的是副本；main 里的 a 还是 5。
排除法：选"编译错误"的人不知道代码合法；选 100 的人以为函数内能改到外面的变量（那是引用传参才能做到）；选 0 的人无依据。
阅读下面的程序：
01void f(int &x) { 02 x = 100; 03} 04 05int main() { 06 int a = 5; 07 f(a); 08 cout << a; 09 return 0; 10}
程序的输出是（ ）。
考点：引用传参（G4）。
（G4）考点：int &x 是引用参数——形参 x 就是实参 a 的别名，函数里改 x 就是改 a，输出 100。
解析：f(a) 后 x 与 a 是同一个变量，x = 100 直接修改了 a。引用传参让函数能"带回"修改。
排除法：选 5 的人套用了值传递的规则（与上一题正好对照）；选 0 的人无依据；选"编译错误"的人不知道引用传参是合法语法。
阅读下面的程序：
01int f(int x) { return x + 1; } 02double f(double x) { return x + 1.5; } 03 04int main() { 05 cout << f(2) << " " << f(2.0); 06 return 0; 07}
程序的输出是（ ）。
考点：函数重载（G5）。
（G5）考点：重载按实参类型选择函数——int 实参调 f(int) 得 3，double 实参调 f(double) 得 3.5。
解析：f(2) 的实参是 int，调用 int f(int)，返回 3；f(2.0) 的实参是 double，调用 double f(double)，返回 3.5。两个函数名字相同但参数类型不同，构成重载。
排除法：选"输出 3 3"的人以为两个调用都走 int 版；选"输出 3.5 3.5"的人以为都走 double 版；选"编译错误"的人不知道重载是允许的。
阅读下面的程序：
01void f(int x, int y = 10) { 02 cout << x + y; 03} 04 05int main() { 06 f(5); 07 return 0; 08}
程序的输出是（ ）。
考点：默认参数（G6）。
（G6）考点：默认参数——调用时缺省第二个参数就用默认值 10，f(5) 等价于 f(5, 10)，输出 15。
解析：f(5) 中 y 取默认值 10，5 + 10 = 15。默认参数只能从右往左连续省略。
排除法：选 5 的人只算了 x 的值（漏了加法）；选"默认参数不合法"的人不知道这是标准语法；选 10 的人输出的是 y 的默认值本身。
阅读下面的程序：
01char c = 'a' + 1; 02cout << c;
程序的输出是（ ）。
考点：字符参与算术（H1）。
（H1）考点：字符可以参与算术——'a' + 1 按 ASCII 码算得 98，对应字符 'b'。
解析：'a' 的 ASCII 码是 97，加 1 得 98，98 对应的字符是 b，所以输出 b。
排除法：选 97 的人输出的是数值结果（98 才对应 b，97 是 a 本身）；选 a 的人以为字符不能运算、结果不变；选"编译错误"的人不知道字符算术是合法的。
阅读下面的程序（已包含头文件 <cmath>）：
cout << sqrt(16) + abs(-3);
程序的输出是（ ）。
考点：数学函数（H2）。
（H2）考点：sqrt(16) 得 4、abs(-3) 得 3，都是 <cmath> 里的函数，表达式整体为 4 + 3 = 7。
解析：，，。
排除法：选 19 的人把 16 与 3 相加了（函数名没起作用）；选"编译错误"的人不知道题干已含 <cmath>；选 5 的人把 sqrt(16) 算成了 2。
阅读下面的程序：
01int x = 5; 02double y = x / 2 + 0.5;
执行后 y 的值是（ ）。
考点：混合运算顺序（H3）。
（H3）考点：x / 2 两个 int 先做整数除法得 2，再加 0.5 得 2.5——除法发生在类型转换之前。
解析：x / 2 = 5 / 2 = 2（整数除法截断），2 + 0.5 = 2.5。
排除法：选 3.0 的人无依据；选 3.5 的人以为 5 / 2 得 2.5（把整数除法当成了实数除法）；选 2.0 的人只算了 x / 2 忘了加 0.5。
在常见的 64 位 Windows / Linux 环境下，阅读下面的程序：
01cout << sizeof(int);
程序的输出是（ ）。
考点：sizeof（H4）。
（H4）考点：sizeof(int) 返回 int 占用的字节数——在常见的 64 位 Windows / Linux 环境下是 4 字节。
解析：sizeof 是编译期运算符，sizeof(int) 得 4，输出 4。int 占 4 字节、long long 占 8 字节、char 占 1 字节是常见环境的约定。
排除法：选 8 的人那是 long long 的大小；选 1 的人那是 char 的大小；选 2 的人那是老式 16 位环境的 int。