第 4 章 C++语言基础 · 知识细节练习

考点：main 函数（A1）。

解析：C++ 程序的执行从 main 函数的第一条语句开始，到 main 返回结束。✅ 正确

排除法：无（判断题）。混淆点：头文件、全局变量的初始化发生在 main 之前，但用户代码的执行入口一定是 main。

关联 · 编译过程（A6）：main 是链接器寻找的入口符号，没有 main 的程序无法链接成可执行文件。

考点：头文件（A2）。

解析：#include 是预处理指令，作用是把指定头文件的内容原样包含到当前源文件（本质是文本复制）。✅ 正确

排除法：无（判断题）。混淆点：#include 不是"引入库"、不是"声明变量"，它是编译前的文本包含。

关联 · 宏定义（A5）：#include 与 #define 都发生在预处理阶段（见 A6）。

考点：命名空间（A3）。

解析：标准库的所有名字（cout、cin 等）都在 std 命名空间中；using namespace std; 把这组名字引入当前作用域，之后可直接写 cout 而不用 std::cout。✅ A

排除法：B using std; 语法错误；C namespace using std; 语序错误；D #include using 不是合法指令。

关联 · 头文件（A2）：#include <iostream> 提供声明，using namespace std; 简化书写——两者常一起出现。

考点：注释（A4）。

解析：// 注释到行尾；/* */ 可跨多行。注释不参与编译，仅用于说明。✅ 正确

排除法：无（判断题）。混淆点：/* */ 不能嵌套（/* /* */ */ 会在第一个 */ 处结束）。

考点：宏定义（A5）。

解析：#define N 100 是预处理指令：编译前把代码中出现的标识符 N 文本替换为 100——它不是变量、不占内存、没有类型。✅ B

排除法：A 宏不是变量；C 宏不是常量对象（const 才是）；D #define 与 #include 作用完全不同。

关联 · const 常量（B3）：const int N = 100; 是真正的常量（有类型、占内存、编译期检查）；宏只是无脑文本替换——推荐用 const。
记忆点：宏是"替换"，const 是"常量"。
大纲注：宏定义（#define）在 NOI 2025 大纲中未明确列出，属初赛高频的预处理常识。

考点：编译过程（A6）。

解析：C++ 源文件 → 预处理（处理 #include/#define）→ 编译（生成目标文件 .o/.obj）→ 链接（合并目标文件与库，生成可执行文件）。✅ 正确

排除法：无（判断题）。混淆点：有人以为"编译"一步到位——链接阶段负责把多个目标文件和库拼起来。

关联 · 头文件（A2）/宏定义（A5）：#include 和 #define 都在预处理阶段完成。

考点：基本类型（B1）。

解析：C++ 基本类型：整型（int）、字符型（char）、布尔型（bool）、浮点型（float/double）。string 是标准库的类，不是基本类型。✅ C

排除法：A/B/D 都是基本类型；string 需要 #include <string> 才能使用。

关联 · 类型大小（B5）：基本类型大小固定（char 1 字节、int 4 字节）；类类型（string）内部含指针，sizeof 不等于字符数。

考点：未初始化变量（B2）。

解析：函数内定义的局部变量不初始化时，其值是不确定的（栈上残留的任意数据）——直接使用是未定义行为。✅ 正确

排除法：无（判断题）。混淆点：定义位置决定初始值——全局变量（函数外定义）和静态变量未初始化时默认是 $0$（静态存储区清零），只有局部变量才是垃圾值。

关联 · 全局 vs 局部：int x; 写在函数外 → 全局，默认 $0$；写在函数内 → 局部，值不确定——同一句声明，位置不同语义不同。
关联 · const 常量（B3）：const int N = 5; 声明即初始化且不可改；普通局部变量先声明后赋值，中间状态不可信。

考点：const 常量（B3）。

解析：const int N = 5; 定义后 N 是只读的，任何修改（N = 6;）都会编译报错。✅ 正确

排除法：无（判断题）。混淆点：const 是编译期检查的常量，与 #define 宏（文本替换）不同（见 A5）。

关联 · 宏定义（A5）：#define N 100 vs const int N = 100——推荐用 const（有类型检查、可调试）。

考点：字面量（B4）。

解析：'a' 是字符字面量（char，占 1 字节）；"a" 是字符串字面量（const char[2]，内容 a + 结尾 '\0'，占 2 字节）。✅ A

排除法：B 两者类型不同；C 'a' 恒为 1 字节；D "a" 至少 2 字节（含结束符）。

关联 · 字符串结尾（第 3 章 F5）：C 风格字符串以 '\0' 结尾——"a" 虽只有一个可见字符，实际占 2 字节。
记忆点：单引号是字符、双引号是字符串——字符串自带一个隐藏的 '\0'。

考点：sizeof（B5）。

解析：C++ 中 'a' 的类型是 char，sizeof('a') = $1$（C 语言里才是 int 4 字节——这是 C 与 C++ 的著名区别）。✅ A

排除法：B $4$ 是 C 语言的结果（或 sizeof(int)）；C $8$ 是 64 位指针大小；D $2$ 是 short 大小。

关联 · 字面量（B4）：'a' 是 char 字面量；sizeof 返回类型占用的字节数。
记忆点：C++ 中 sizeof('a') = 1，见到直接选 1。

考点：浮点字面量（B6）。

解析：小数默认是 double（双精度）；加后缀 f/F 才是 float（单精度）。✅ 正确

排除法：无（判断题）。混淆点：3.14 与 3.14f 精度不同——float 约 7 位有效数字、double 约 15 位（见第 3 章 D6）。

关联 · 浮点精度（第 3 章 D6）：float 精度有限；需要高精度时用 double 或 long double。

考点：混合除法陷阱（B7）。

解析：a / b 中两个操作数都是 int，先按整数除法得 $3/2 = 1$，再把结果 $1$ 转成 double 赋给 c——所以 c = 1.0。✅ B

排除法：A $1.5$ 是"先转 double 再除"（需要写 a * 1.0 / b）；C/D 无来源。

关联 · 整型除法（第 3 章 D3）：int/int 结果仍为 int，小数部分丢弃——想保留小数必须让至少一个操作数变成浮点。
记忆点：double c = a / b; ≠ a / b 的精确值——除法类型看操作数，不看赋值目标。

考点：取模（C1）。

解析：C++ 中取模结果符号与被除数一致：$-7 = (-2) \times 3 + (-1)$，所以 $-7 \% 3 = -1$。✅ A

排除法：B $1$ 是数学上的绝对值余数；C/D 是无来源的错值。

关联 · 算术运算（第 3 章 D3）：取模只适用于整数；a % b 的结果满足 $a = q \times b + r$ 且 $|r| < |b|$，符号与 $a$ 相同。
验算：$7 \% 3 = 1$（正数），$-7 \% 3 = -1$，$7 \% (-3) = 1$ ✓

考点：自增自减（C2）。

解析：i++ 是后缀自增：先取原值参与表达式，再自增。所以 x = i++ 先得 x = 3，然后 i 变 4。✅ A

排除法：B $x = 4$ 是前缀 ++i 的结果；C 两个都没变；D 方向记反。

关联 · 优先级（C7）：i++ 与 ++i 单独使用时效果相同；在表达式里才显区别——后缀"先用后加"、前缀"先加后用"。
记忆点：i++ = 先给我，再自增；++i = 先自增，再给我。

考点：复合赋值（C3）。

解析：x += 2 是复合赋值运算符，等价于 x = x + 2。同类：-=、*=、/=、%=、<<=、&= 等。✅ 正确

排除法：无（判断题）。混淆点：x += 2 与 x = x + 2 在求值上几乎等价（唯一的细微差别是 x 只求值一次）。

关联 · 位运算（第 2 章 D3）：s |= 1 << 3 就是复合赋值 + 位或——|= 等价 s = s | (...)。

考点：短路求值（C4）。

解析：&& 左操作数为假时，结果必为假，右侧不再计算（短路）；|| 左为真时右侧也不计算。✅ 正确

排除法：无（判断题）。混淆点：&（位与）会两边都算——&& 是逻辑短路、& 是位运算不短路。

关联 · 逻辑运算（第 2 章 H1）：&&/|| 是逻辑运算（结果 true/false），&/| 是位运算（逐位计算）——运算符不同，行为不同。
记忆点：短路 = "能定结果就不往后算"——常用 p && *p 防空指针。

考点：三目运算（C5）。

解析：a > b ? a : b：条件为真取 a，为假取 b。$5 > 3$ 为真，所以 m = 5。✅ A

排除法：B $3$ 是条件为假时的值；C $1$ 是 a - b 或条件表达式本身的值；D $8$ 是 a + b。

关联 · if-else（D1）：三目运算 c ? x : y 等价于简化版 if (c) x; else y;，但三目是表达式（有值）。

考点：逗号表达式（C6）。

解析：逗号表达式从左到右依次计算每个子表达式，整个表达式的值是最后一个：(1, 2, 3) 先算 1、2（丢弃），值为 3。✅ C

排除法：A/B 是中间子表达式的值；D 逗号表达式合法，不会编译错误。

关联 · 优先级（C7）：逗号运算符优先级最低——int x = 1, 2, 3; 与 int x = (1, 2, 3); 完全不同（前者声明 x=1 并额外列出 2、3 无效）。
记忆点：逗号表达式"取最后"。

考点：优先级综合（C7）。

解析：* 与 % 同级（高于 +），且从左到右结合：2 + 3 * 4 % 5 = 2 + (3*4) % 5 = 2 + 12 % 5 = 2 + 2 = $4$。✅ A

排除法：B $14$ 是 (2+3)*4%5 或直接左到右混算；C $2$ 是只算 3*4%5 忘了加 2；D $0$ 是 12%5 记错（=2 不是 0）。

关联 · 优先级链（第 2 章 A6）：完整链 << >> → 关系 → == → & → ^ → | → && → ||；算术运算（*///%）在关系之前。
验算：$12 \% 5 = 2$，$2 + 2 = 4$ ✓

考点：else 就近配对（D1）。

解析：else 与前面最近的、尚未配对的 if 结合（"就近原则"）——即使缩进看起来属于另一个 if。✅ 正确

排除法：无（判断题）。混淆点：代码缩进只是给人看的，编译器只认就近原则——嵌套 if 时用 {} 明确分组。

关联 · 控制结构（D6）：if 的条件按真假判定（0 假、非 0 真）。

考点：switch 贯穿（D2）。

解析：case 是一组"入口标签"：匹配后从该处顺序往下执行，遇到 break 才跳出——没有 break 就贯穿（fall-through）到下一个 case。✅ A

排除法：B 只有 break 才跳出；C 贯穿合法；D 贯穿会继续执行后面的 case 而不是跳过。

关联 · if-else（D1）：switch 适合多分支定值比较；每个分支末尾写 break 是防贯穿的标准做法。

考点：for 循环次数（D3）。

解析：for (int i = 0; i < 3; i++)：$i = 0, 1, 2$ 各执行一次循环体（$i = 3$ 时条件为假停止），共 $3$ 次。✅ B

排除法：A $2$ 次是 i < 2；C $4$ 次是 i <= 3；D 无限次是步进缺失（如忘写 i++）。

关联 · 循环边界（D7）：i < n 执行 $n$ 次（$0 \sim n-1$），i <= n 执行 $n+1$ 次——写循环先数清次数。

考点：do-while（D4）。

解析：do { ... } while (条件); 先执行一次循环体、再判断条件——所以至少执行一次。✅ 正确

排除法：无（判断题）。混淆点：while 先判断后执行（可能一次都不执行）；do-while 先执行后判断（至少一次）——注意结尾分号。

关联 · while 循环（D3）：需要"至少执行一次"的场景（如菜单选择、先读后判）用 do-while。

考点：break/continue（D5）。

解析：continue 跳过本次循环的剩余语句，直接进入下一次迭代（条件判断）；break 才是结束整个循环。✅ B

排除法：A 是 break 的作用；C 结束程序需要 return/exit；D 跳到循环开头是"继续下一次"，不是死循环。

关联 · 嵌套循环（D8）：break/continue 只作用于最近一层循环；跳出多层要用标志变量或 return。

考点：真假判定（D6）。

解析：C++ 中整数作为条件：$0$ 为假，任何非 0 值（包括负数）为真。✅ 正确

排除法：无（判断题）。混淆点：if (x) 判断的是"x 是否非 0"，不是"x 是否为 true"——if (-1) 也为真。

关联 · 逻辑运算（C4）：&&/|| 的结果是 bool；而条件位置接受任意整型/指针（非 0 即真）。

考点：循环边界（D7）。

解析：输出 $1 \sim 10$：for (int i = 1; i <= 10; i++)——从 1 开始、<= 10 结束，正好 10 次。✅ A

排除法：B i < 10 只输出 $1 \sim 9$；C i = 0 输出 $0 \sim 9$；D i <= 11 输出 $1 \sim 11$。

关联 · for 循环次数（D3）：<= 比 < 多一次；"输出 1 到 n"用 i = 1; i <= n，"遍历数组 0..n-1"用 i = 0; i < n。
记忆点：含端点用 <=、不含用 <——off-by-one 是最常见的边界错误。

考点：循环变量作用域（D8）。

解析：for (int i = 0; ...) 中 i 声明在 for 的初始化部分，作用域限于该循环——循环结束后访问 i 会编译错误。✅ 错误

排除法：无（判断题）。混淆点：int i; for (i = 0; ...) 把 i 声明在循环外，循环结束后才可访问。

关联 · 作用域（E3）：变量的作用域 = 声明处到所在块结束；循环内声明的变量随循环结束而消亡。

考点：先声明后调用（E1）。

解析：C++ 从上到下编译：调用函数时，编译器必须已见到该函数的定义或声明——否则报"未声明"错误。✅ 正确

排除法：无（判断题）。混淆点：main 写在前面、函数定义在后面时，需要在前面加函数声明（原型）：int f(int);。

关联 · 函数定义与调用（E2）：声明（原型）只写返回类型/函数名/参数；定义才带函数体。

考点：返回值（E2）。

解析：int 函数没有 return 语句时，返回的是不确定的值（未定义行为）——不能假设是 0。✅ 正确

排除法：无（判断题）。混淆点：void 函数不需要返回值；但非 void 函数漏 return 是常见 bug。

关联 · 递归（E7）：递归函数必须有明确的返回路径（递归出口），否则结果不确定或无限递归。

考点：值传递（E3）。

解析：按值传递时，实参的值复制给形参——函数内修改的是副本，实参不受影响。✅ 正确

排除法：无（判断题）。混淆点：数组、指针、引用是例外（见 F5、E4）——普通变量按值传。

关联 · 引用传参（E4）：需要函数修改实参时用引用 int &x；不需要修改时按值传（或 const & 避免复制开销）。

考点：引用传参（E4）。

解析：int &x 是引用参数——x 是实参 a 的别名，x++ 直接修改 a：$5 \to 6$。✅ B

排除法：A $5$ 是按值传递的结果；C 引用传递结果确定；D 语法合法。

关联 · 值传递（E3）：值传递"改不到外面"，引用传递"改得到"——swap(a, b) 必须用引用/指针实现。
验算：f(a) 后 a = 5 + 1 = 6 ✓

考点：函数重载（E5）。

解析：C++ 允许同名函数、参数列表不同（个数/类型/顺序），调用时按实参匹配——这叫函数重载。✅ 正确

排除法：无（判断题）。混淆点：仅返回值不同不算重载（无法区分调用）；参数列表必须真的不同。

关联 · 函数定义（E1）：重载是 C++ 多态的一种（编译期多态），典型例子：max(int, int)、max(double, double)。

考点：默认参数（E6）。

解析：int f(int x, int y = 10); 中 y 有默认值：f(5) 等价 f(5, 10)，y = 10。✅ B

排除法：A $5$ 是 x 的值；C $0$ 是未初始化；D 缺省实参合法，不会编译错误。

关联 · 函数声明（E1）：默认参数写在声明（原型）里；默认值只能从右侧开始给（f(int x = 1, int y) 非法）。

考点：递归（E7）。

解析：f(4) = $4 \times f(3)$ = $4 \times 3 \times f(2)$ = $4 \times 3 \times 2 \times f(1)$ = $4 \times 3 \times 2 \times 1$ = $24$（$n \le 1$ 是递归出口）。✅ A

排除法：B $10$ 是 $1+2+3+4$（加法记混）；C $4$ 是直接返回 n；D $16$ 是 $4^2$ 或 $2^4$。

关联 · 递归出口（E2）：递归 = 自己调用自己 + 明确的出口条件；n <= 1 是这里的出口，缺出口会无限递归（栈溢出）。
验算：$4! = 4 \times 3 \times 2 \times 1 = 24$ ✓

考点：指针与解引用（F1）。

解析：int *p = &x; 中 p 存的是 x 的地址；*p 是解引用，取该地址上的值 = $5$。✅ A

排除法：B x 的地址是 p 的值（不是 *p）；C p 的地址是 &p；D 语法合法。

关联 · 指针算术（F3）：指针存地址、* 取值、& 取址——三个符号的关系是初学第一关。

考点：数组名退化（F2）。

解析：除 sizeof 和 & 操作符外，数组名在表达式中自动退化为指向首元素的指针：int a[5]; 中 a 等价 &a[0]。✅ 正确

排除法：无（判断题）。混淆点：sizeof(a) 仍是整个数组的大小（$5 \times 4$ 字节），不退化——"退化"只发生在表达式求值中。

关联 · 传数组（F5）：正因为退化，函数参数写 int a[] 和 int *a 完全等价。

考点：指针算术（F3）。

解析：p + 2 指向 p 之后第 2 个元素（不是第 2 个字节）；p 指向 a[0]，所以 *(p + 2) = a[2]。✅ A

排除法：B a[3] 是 *(p+3)；C/D 是 p+0、p+1。

关联 · 数组名退化（F2）：a[i] 等价 *(a + i)——数组下标本质是指针算术的语法糖。
记忆点：指针 +1 跳过一个元素（int 指针 +1 = 地址 +4 字节）。

考点：空指针解引用（F4）。

解析：nullptr（或 NULL）不指向任何有效对象；对空指针解引用（*p）是未定义行为，程序通常崩溃（段错误）。✅ 正确

排除法：无（判断题）。混淆点：空指针判断用 if (p)（非 0 为真）或 if (p != nullptr)——先判空再解引用是安全写法。

关联 · 短路求值（C4）：if (p && *p > 0) 利用短路：p 为空时不再解引用——安全访问的经典写法。

考点：传数组进函数（F5）。

解析：数组作参数时退化为指针，函数收到的是首元素地址——函数内修改数组元素会影响原数组，且 sizeof 得到的是指针大小。✅ 正确

排除法：无（判断题）。混淆点：以为"整个数组复制过去"——数组不按值传递（C++ 中 int a[] 参数等价 int *a）。

关联 · 数组名退化（F2）：退化机制是"传数组=传地址"的根本原因；通常需要额外传数组长度参数。

考点：引用 vs 指针（F6）。

解析：指针可以不初始化（危险），也可以改指向；引用必须初始化、且一旦绑定不可改绑。✅ B

排除法：A 引用不可改绑（错）；C 引用必须初始化（错）；D 两者语义不同（引用是别名、指针是地址变量）。

关联 · 引用传参（E4）：函数参数用引用（int &x）比指针安全（不用判空）；但需要"可改指向/可为空"时用指针。
记忆点：引用 = 别名（初始化即绑定终身）；指针 = 地址变量（可空、可换）。

考点：结构体成员访问（G1）。

解析：普通结构体变量用点运算符 . 访问成员：s.x；指针才用 ->（p->x 等价 (*p).x）。✅ B

排除法：A -> 用于结构体指针；C :: 是作用域运算符（类/命名空间用）；D *s.x 是先取成员再解引用，语义错误。

关联 · 结构体数组（G2）：S arr[10]; arr[0].x = 1;——数组元素是结构体，用 . 访问。

考点：结构体数组（G2）。

解析：结构体是用户自定义类型，可以像基本类型一样定义数组：S arr[10] 创建 10 个 S 对象。✅ 正确

排除法：无（判断题）。混淆点：访问元素成员要两步——先下标再点：arr[2].a。

关联 · 成员访问（G1）：arr[i].a = 先取第 i 个元素，再取它的 a 成员。

考点：枚举（G3）。

解析：枚举常量默认从 $0$ 开始递增：RED = 0、GREEN = 1、BLUE = 2。✅ A

排除法：B/C 是后续枚举值；D 枚举值确定，不是随机。

关联 · typedef（G4）：枚举把一组有名字的整数常量打包；enum class（C++11）更严格（需强转才能与整数比较）。

考点：typedef（G4）。

解析：typedef long long ll; 定义类型别名：之后 ll x; 等价 long long x;——不创建变量、不做替换。✅ A

排除法：B typedef 不声明变量；C 文本替换是 #define（宏）；D 引入头文件是 #include。

关联 · 宏定义（A5）：typedef 是类型别名（编译期、有类型检查）；#define 是文本替换（预处理期、无检查）——类型别名优先用 typedef/using。

考点：string（G5）。

解析：string 是类类型，length() 返回实际字符个数，不含结束符："abc" 长度为 $3$。✅ A

排除法：B $4$ 是 C 风格字符串 sizeof 的结果（含 '\0'，见第 3 章 F5）；C/D 无来源。

关联 · 字符串结尾（第 3 章 F5）：char s[] = "abc" 占 4 字节（含 '\0'）；string s = "abc" 的 length() = 3——"C 字符串按字节含结束符、string 按字符不含"，两者对照记忆。

考点：字符参与算术（H1）。

解析：char 参与算术时先提升为 int：'A' 的 ASCII 码是 $65$，65 + 1 = 66——cout 输出整数 $66$，不是字符 'B'。✅ B

排除法：A 输出字符 B 需要先转回 char（char('A'+1)）；C A1 是字符串拼接；D 合法不会编译错误。

关联 · ASCII 码（第 1 章）：'A' = 65、'a' = 97、'0' = 48——字符与整数的桥梁。
记忆点：'A' + 1 是整数 66；char c = 'A' + 1 才是字符 'B'。

考点：= 与 ==（H2）。

解析：x = 5 是赋值（把 5 给 x，表达式的值就是 5，非 0 恒为真）；x == 5 才是比较。两者效果完全不同，且 if (x = 5) 还悄悄改了 x。✅ 错误

排除法：无（判断题）。混淆点：编译器常告警"assignment in condition"；写成 if (5 == x) 可防手滑（常数在左，赋值会报错）。

关联 · 真假判定（D6）：x = 5 的值是 5（非 0 → 真），x = 0 的值是 0（假）——赋值表达式也有值。
记忆点：= 是"给"，== 是"问"。

考点：cout 表达式（H3）。

解析：1 / 2 是 int/int = $0$（整除）；1.0 / 2 是 double/int = $0.5$。输出 0 0.5。✅ A

排除法：B 0.5 0.5 把 1/2 也当浮点；C 0 0 把 1.0/2 也当整除；D 1 0.5 把 1/2 当四舍五入。

关联 · 混合除法陷阱（B7）：除法结果看操作数类型——有一个浮点就是浮点除法。
验算：$1/2 = 0$（int），$1.0/2 = 0.5$ ✓

考点：混合运算顺序（H4）。

解析：* 与 / 同级、从左到右：1.0 * 3 = $3.0$（double），3.0 / 2 = $1.5$。✅ A

排除法：B $1$ 是 3 / 2 整除后再乘 1.0（3 / 2 * 1.0 = 1.0）；C $1.0$ 同上记混；D $3$ 是 1.0 * 3 只算一半。

关联 · 优先级综合（C7）：*///% 同级左结合——先除后乘与先乘后除在浮点语境结果不同（3 / 2 * 1.0 = 1.0，1.0 * 3 / 2 = 1.5）。
记忆点：浮点"掺和"越早，精度损失越小——1.0 * 放最前面最安全。