CSP-J 学习卷 L01 · 程序编译与运行

规则：位 bit 是计算机里最小的信息单位，只能表示 0 或 1 两种状态。

考点：位字节字。

解析：8 个 bit 组成 1 个 Byte，2 个 Byte 组成 1 个字（16 位机）……一切更大的单位都由 bit 拼出来，所以最小单位是 bit。

易错：把「最小存储单位」和「基本存储单位」搞混——基本单位常指字节，最小是位。

排除法：字节/字/KB 都比位大，由位组成。

规则：1 Byte = 8 bit，这是所有容量换算的基础。

考点：位字节字。

解析：字节是存储器的基本单位，1 个字节能表示 $2^8=256$ 种状态（一个字符、一个 0~255 的数）。

排除法：16 位是 1 个字（16 位机）；10 位是十进制思维的误导；4 位是半个字节（nibble）。

规则：位最小，字节 = 8 位，字是 CPU 一次能处理的数据宽度（16/32/64 位，即 2/4/8 字节）。

考点：位字节字。

解析：字长由 CPU 位数决定（64 位机的字 = 64 位 = 8 字节），所以 字 ≥ 字节 > 位 恒成立。

易错：字的大小随机器变，但总 ≥ 1 字节。

排除法：字节不可能大于字；位不可能最大。

规则：计算机只认 0/1 二进制，一切信息最终都编码成二进制序列存储。

考点：计算机基本构成/二进制。

解析：文字→ASCII/Unicode 码、图像→像素位图、声音→采样数据，全部归根结底是一串 0 和 1。

排除法：十进制是人的习惯；ASCII 只是文字的一种编码；电压高低是物理实现（高=1 低=0），不是「存储形式」。

规则：n 个 bit 有 $2^n$ 种取值组合。

考点：位字节字。

解析：1 bit 有 0/1 共 2 种；2 bit 有 00/01/10/11 共 4 = 2² 种；推广到 n bit 就是 $2^n$ 种。

排除法：n²、2n 是把「位数」当「指数底数」的错误；10ⁿ 是十进制思维。

规则：字节数 = 位数 ÷ 8。

考点：位字节字。

解析：32 位 ÷ 8 = 4 字节。（真题 2019 原题考法）

易错：32 位 ≠ 32 字节，位和字节差 8 倍。

排除法：2 字节是 16 位；8 字节是 64 位；32 字节是位/字节混淆。

规则：计算机容量单位按 1024 进位：1 KB = 1024 B = $2^{10}$ 字节。

考点：容量单位。

解析：1 KB = $2^{10}$ B = 1024 B；1 MB = 1024 KB；1 GB = 1024 MB。（真题 2023/2024 考法）

易错：磁盘厂商习惯按 1000 标称，但计算机内存按 1024 计算——题目默认 1024。

排除法：1000 是十进制标称；1024 位/8 字节单位混淆。

规则：1 MB = $2^{20}$ 字节，再 ×8 = $2^{23}$ 位。

考点：容量单位（真题 2024 考法）。

解析：1 MB = 1024 KB = $2^{10} \times 2^{10}$ B = $2^{20}$ B，1 字节 8 位 → $2^{20} \times 8 = 2^{23}$ 位。

易错：先乘 8 再换算，或把 1024 当 1000。

排除法：$10^6$ 是按 1000×1000 且没乘 8；$2^{20}$ 是字节数不是位数；$10^7$ 是 1000×1000×8 的十进制版本。

规则：位图大小 = 像素数 × 每像素位数 ÷ 8。

考点：容量单位（真题 2020 考法）。

解析：$2048\times1024 = 2^{11} \times 2^{10} = 2^{21}$ 像素，×32 位 = $2^{26}$ 位，÷8 = $2^{23}$ 字节 = 8 MB。

易错：像素数、位数、÷8 三步顺序错一步就错。

排除法：4 MB 少乘了 32 位（当 16 位算）；16 MB 是乘了 64 位；64 MB 是位字节没转换。

规则：容量大小：1 TB > 1 GB > 1 MB > 1 KB。

考点：容量单位（真题 2023 考法）。

解析：B < KB < MB < GB < TB，每级 1024 倍，所以 1 KB 最小。

排除法：GB/MB/TB 都比 KB 大。

规则：编译器 = 翻译官，把高级语言（C/C++）源码翻译成机器能执行的机器语言。

考点：编译器（真题 2020/2024 考法）。

解析：源码（.cpp）→ 编译器 → 可执行程序。运行程序是操作系统/CPU 的事；编译和运行是两个阶段。

易错：把「编译」和「运行」混为一谈——编译产生可执行文件，运行是执行它。

排除法：运行是解释器/CPU 的事；整理磁盘是系统工具；上网与编译无关。

规则：流程 = 写源码 → 编译（生成可执行文件）→ 运行（执行）。

考点：编译运行流程。

解析：Dev-C++ 里「编译运行」按钮 = 先编译再运行；编译通过才有可执行文件；编译一次可运行任意多次。

排除法：先运行后编译顺序颠倒；两者不同阶段；编译一次可多次运行。

规则：C++ 源码扩展名 .cpp；编译后生成 .exe 可执行文件。

考点：编译运行流程。

解析：写代码存成 1.cpp → 编译出 1.exe → 运行 1.exe。

排除法：.exe 是编译产物；.doc/.txt 是文档/纯文本。

规则：#include 是预处理指令，把指定头文件的内容包含进来。

考点：头文件（KJ-13c）。

解析：iostream 头文件声明了 cin/cout 等输入输出对象，不包含它就无法使用 cin/cout。

排除法：定义函数/主函数/结束程序都不是 include 的职责。

规则：程序从 main 函数的第一条语句开始执行。

考点：程序基本概念（KJ-13a）。

解析：无论 main 写在文件哪里，程序都从 main 开始；include/变量定义只是准备工作。

排除法：include 是预处理；变量定义是声明；cout 是 main 里的一条语句。

规则：最小可编译程序 = #include <iostream> + using namespace std; + int main(){ ... return 0; }。

考点：程序骨架。

解析：include 提供输入输出、using 简化命名空间访问、main 是入口、return 0 表示正常结束。前三者缺一不可（return 0 可省但规范要求）。

排除法：return 0 可省；注释/全局变量非必需。

规则：预处理（处理 #include/#define）→ 编译（翻译成机器码的目标文件）→ 链接（把多个目标文件合成可执行文件）。

考点：编译过程（KJ-13d）。

解析：Dev-C++ 一键「编译运行」内部自动完成这三步，但概念上顺序固定。

排除法：顺序颠倒；不是一步。

规则：编译错误 = 语法/类型错，编译器报错不生成 exe；运行时错误 = 语法对但执行时出错（除以 0、数组越界）。

考点：编译运行流程。

解析：少写分号 → 编译错误；int x=1/0 → 运行时错误（程序崩溃）。

易错：数组越界常是运行时错误而非编译错误。

排除法：运行时错误不是编译期发现；反之亦然。

规则：Dev-C++ 的「编译运行」= 编译（生成 exe）+ 自动运行。

考点：开发环境（KJ-10）。

解析：有输入的程序运行后会弹出黑色控制台窗口等输入；编译失败会报错不运行。

排除法：保存是 Ctrl+S；只检查语法是「编译」不带运行；Dev-C++ 不负责上传。

规则：Windows 可执行文件 .exe；源码 .cpp；头文件 .h；.o 是中间目标文件（Linux）。

考点：编译产物。

解析：编译 1.cpp 得到 1.exe，双击/命令行运行它。

排除法：.cpp 是源码；.h 是头文件；.o 是编译中间产物不是最终可执行文件。

规则：先 KB→字节（×1024），再字节→位（×8）。

考点：容量单位换算。

解析：2 KB = 2×1024 = 2048 字节 = 2048×8 = 16384 位。

易错：忘记中间 ×1024 或漏 ×8。

排除法：8192 只乘了 ×4；2000/16000 用了十进制 1000。

规则：ASCII 用 7~8 位表示一个字符，存 1 个字节。

考点：字符编码基础。

解析：'A' 的 ASCII 码是 65，二进制 1000001，1 字节装得下。汉字（UTF-8）才要 3 字节。

易错：把 ASCII（1 字节）和 UTF-8 汉字（3 字节）搞混。

排除法：2/4/8 字节是 Unicode/整型/长整型的宽度。

规则：sizeof(类型) 返回该类型占的字节数。

考点：基本数据类型大小。

解析：int 通常 4 字节（32 位）；char 1 字节；long long 8 字节。

排除法：2 是 short；8 是 long long；16 不存在。

规则：int 上限约 $2.1\times10^9$，long long 上限约 $9.2\times10^{18}$。

考点：数据类型范围。

解析：$10^{18}$ 超出 int（$\approx2.1\times10^9$）的范围，必须用 64 位 long long。

易错：竞赛里算错范围导致溢出，是最常见错误之一。

排除法：int/short/char 都远不够。

规则：1 字节 8 位，无符号范围 0 ~ $2^8-1$ = 0~255。

考点：字节与存储范围。

解析：8 位二进制最小 00000000=0，最大 11111111=255；有符号才分正负。

易错：无符号和有符号范围搞混（有符号 char 是 -128~127）。

排除法：0~127 是 7 位；-128~127 是有符号；0~256 超出 8 位上限。

规则：位最小，字节 = 8 位，字 ≥ 字节。

考点：位字节字综合。

解析：1 位 < 1 字节（8 位）< 1 字（16/32/64 位）。

排除法：其余顺序都颠倒了。

规则：链接 = 把编译产生的多个目标文件 + 库合并成最终可执行文件。

考点：编译过程。

解析：用了 <iostream> 库，链接时把库代码和你写的代码合并成 exe；链接错误常见于「找不到库/重复定义」。

排除法：翻译成汇编/机器码是编译阶段；命名检查是编译器的词法分析。

规则：endl = 换行 + 刷新输出缓冲区；\n 只换行。

考点：输入输出基础。

解析：endl 和 \n 都能换行，但 endl 还会刷新缓冲区（小批量输出时更稳妥）。

易错：大循环输出时 endl 频繁刷新会变慢，竞赛常用 \n。

排除法：不是清空变量/结束程序；「只换行不清空」是 \n 的特性。

规则：main 返回 0 表示程序正常结束（惯例）；非 0 表示异常。

考点：程序骨架。

解析：return 0 是「告诉系统：我正常跑完了」。虽然可省略（编译器默认补 0），但规范写法保留。

排除法：返回 0 不是出错；不是返回给 main 自己；有含义不是无意义。

规则：注释给程序员看，编译器完全忽略，不影响运行。

考点：程序基本概念。

解析：// 单行注释，/* */ 多行注释；写注释是好习惯，但可有可无。

排除法：注释不参与编译；不是必须；两种都是合法注释。

规则：使用变量前必须先声明类型；int a = 5; 声明并初始化。

考点：变量（KJ-13a/14a）。

解析：int a = 5; = 声明一个整型变量 a 并赋初值 5；a = 5; 必须在 a 已声明后才有意义；5 = a 语法错误（不能给常量赋值）。

易错：未初始化的局部变量值是「不确定的脏数据」，用前一定要赋值。

排除法：a=5 缺声明；5=a 给常量赋值非法；「不赋值直接 用」的局部变量是未定义行为。

规则：总字节 = 元素个数 × 单元素字节数。

考点：容量综合。

解析：100000 × 8 = 800000 字节 = 800000/1024 ≈ 781 KB ≈ 0.8 MB。

易错：忘记 ×8，或 KB/MB 换算用 1000。

排除法：100 KB 没乘 8；800 MB 多乘了 1000 倍；8 MB 是 800 万字节才对应。

规则：1e6 × 4 B = 4e6 B ≈ 3.8 MB。

考点：容量综合。

解析：$10^6 \times 4 = 4\times10^6$ 字节 ≈ 4 MB。

易错：把 int 当 1 字节；竞赛中数组太大（如 1e8）会内存超限（MLE）。

排除法：4 KB 是 1e3 的量级；40 MB 多乘了 10；400 KB 差一个数量级。

B：4。1 字节=8 位，32 位整型占 32÷8=4 字节；A 直接把位当字节错，C 128 位是更大类型错，D 8 字节对应 64 位整型。

C：8MB。32 位=4 字节/像素，2048×1024=2²¹ 像素，存储 2²¹×4=2²³ 字节=8MB；A 16MB 是 64 位/像素错，B 4MB 是 8 位/像素错，D 32MB 多算。

B：比特（bit）。bit < byte < word < kilobyte；bit 是最小单位 0/1。

D：8388608。1MB=1024×1024=1048576 字节=1048576×8=8388608 位。

A：将源程序翻译成机器指令代码。编译器核心功能是把高级语言源程序翻译为机器指令（目标代码）；B 是预处理/优化混淆，C 反向错，D 高级语言间翻译不是编译器主要职责。

B：将源代码转换为机器代码。编译器核心功能是源程序→目标代码（机器指令/汇编）；A 错（直接执行是解释器），C 错（调试器），D 错（运行时/内存由 OS 管理）。