2024年3月全国计算机等级考试真题（二级C语言）

😀 第1题

下列叙述中正确的是

A. 矩阵是非线性结构 B. 数组是长度固定的线性表

C. 对线性表只能作插入与删除运算 D. 线性表中各元素的数据类型可以不同

题目解析：

A. 矩阵是非线性结构
错误。矩阵通常是二维数组，属于线性结构，因为其元素在内存中是按顺序存储的。

B. 数组是长度固定的线性表
正确。数组是一种线性表，且其长度在定义时固定，无法动态改变。

C. 对线性表只能作插入与删除运算
错误。线性表不仅支持插入和删除，还支持查找、修改等操作。

D. 线性表中各元素的数据类型可以不同
错误。线性表中的元素数据类型必须相同，这是线性表的基本特性。

😀 第2题

在快速排序法中，每经过一次数据交换（或移动）后

A. 能消除多个逆序 B. 只能消除⼀个逆序

C. 不会产生新的逆序 D. 消除的逆序个数⼀定比新产生的逆序个数多

题目解析：

在快速排序法中，每经过一次数据交换（或移动）后：

A. 能消除多个逆序
正确。快速排序通过选取基准元素，将数组分为两部分，使得左边的元素都小于基准，右边的元素都大于基准。这样一次交换可以消除多个逆序。

B. 只能消除一个逆序
错误。快速排序的一次交换通常可以消除多个逆序，而不仅仅是一个。

C. 不会产生新的逆序
错误。快速排序的过程中可能会产生新的逆序，尤其是在分区过程中。

D. 消除的逆序个数一定比新产生的逆序个数多
错误。虽然快速排序的效率较高，但并不能保证每次交换后消除的逆序个数一定比新产生的逆序个数多。

😀 第3题

线性表的长度为n。在最坏情况下，比较次数为n-1的算法是

A. 顺序查找 B. 有序表的插入

C. 寻找最大项 D. 同时寻找最大项与最小项

题目解析：

线性表的长度为 n。在最坏情况下，比较次数为 n−1 的算法是：

A. 顺序查找
错误。顺序查找在最坏情况下需要比较 n 次（查找失败时）。

B. 有序表的插入
错误。有序表的插入在最坏情况下需要比较 n 次（插入到表头时）。

C. 寻找最大项
正确。寻找最大项需要遍历整个线性表，比较次数为 n−1 次。

D. 同时寻找最大项与最小项
错误。同时寻找最大项和最小项的最优算法比较次数为 ⌈3n/2⌉−2，而不是 n−1。

😀 第4题

设某棵树的度为3，其中度为2、1、0的结点个数分别为3、4、15。则该树中总结点数为

A. 22 B. 30 C. 35 D. 不可能有这样的树

题目解析：

😀 第5题

下列叙述中正确的是

A. 软件的使用存在老化问题 B. 软件是物理实体，不具有抽象性

C. 软件是逻辑实体，具有抽象性 D. 软件的运行对计算机系统不一定具有依赖性

题目解析：

A. 软件的使用存在老化问题
错误。软件不会像硬件一样老化，但可能会因为环境变化（如操作系统更新）而变得不兼容或需要更新。

B. 软件是物理实体，不具有抽象性
错误。软件是逻辑实体，具有抽象性，而不是物理实体。

C. 软件是逻辑实体，具有抽象性
正确。软件是逻辑实体，其本质是代码和算法，具有高度的抽象性。

D. 软件的运行对计算机系统不一定具有依赖性
错误。软件的运行依赖于计算机系统（如操作系统、硬件等），没有计算机系统，软件无法运行。

😀 第6题

软件系统总体结构图的作用是

A. 描述软件系统结构的图形公具 B. 描述软件系统的控制流

C. 描述软件系统的数据流 D. 描述软件系统的数据结构

题目解析：

软件系统总体结构图的作用是：

A. 描述软件系统结构的图形工具
正确。软件系统总体结构图用于描述系统的模块划分、模块之间的关系以及系统的层次结构，是一种图形化的表示工具。

B. 描述软件系统的控制流
错误。控制流通常由程序流程图或状态图描述，而不是总体结构图。

C. 描述软件系统的数据流
错误。数据流通常由数据流图（DFD）描述，而不是总体结构图。

D. 描述软件系统的数据结构
错误。数据结构通常由类图、ER图等描述，而不是总体结构图。

😀 第7题

下面不属于结构化程序设计风格的是

A. 程序结构良好 B. 程序的易读性 C. 不滥用Goto语句 D. 程序的执行效率

题目解析：

结构化程序设计风格强调程序的可读性、可维护性和良好的程序结构，而不是单纯追求执行效率。

A. 程序结构良好
属于。结构化程序设计强调程序结构的清晰性和模块化。

B. 程序的易读性
属于。结构化程序设计注重代码的可读性，便于理解和维护。

C. 不滥用Goto语句
属于。结构化程序设计主张避免使用Goto语句，以保持程序结构的清晰性。

D. 程序的执行效率
不属于。执行效率通常与算法优化和硬件性能相关，而不是结构化程序设计的核心目标。

😀 第8题

将数据库的结构划分成多个层次，是为了提高数据库的物理独立性和

A. 规范程度 B. 操作独立性 C. 逻辑独立性 D. 降低数据冗余

题目解析：

数据库的结构划分成多个层次（如外模式、概念模式和内模式），主要是为了提高数据库的物理独立性和逻辑独立性。

A. 规范程度
错误。规范程度通常通过数据库设计范式来实现，而不是通过层次划分。

B. 操作独立性
错误。操作独立性不是数据库层次划分的主要目标。

C. 逻辑独立性
正确。数据库的层次划分可以提高逻辑独立性，使得应用程序不受数据库逻辑结构变化的影响。

D. 降低数据冗余
错误。降低数据冗余主要通过数据库设计范式实现，而不是层次划分。

😀 第9题

学院的每名教师只能属于一个系，则实体系和实体教师间的联系是

A. 一对多 B. 多对多 C. 多对一 D. 一对一

题目解析：

根据题意，学院的每名教师只能属于一个系，而一个系可以包含多名教师。因此，实体“系”和实体“教师”之间的联系是：

一个系对应多个教师（“系”到“教师”是一对多）。
一个教师只能属于一个系（“教师”到“系”是多对一）。

综合来看，这种关系是 一对多（从“系”到“教师”的角度）。

😀 第10题

定义学生选修课程关系模式SC(S#,Sn,C#,Cn,G)（其属性分别为学号、姓名、课程号、课程

名、成绩）该关系的范式最高达到

A. 1NF B. 2NF C. 3NF D. BCNF

题目解析：

关系模式 SC(S#,Sn,C#,Cn,G) 的属性分别为学号、姓名、课程号、课程名、成绩。

1NF（第一范式）
该关系模式中，每个属性都是原子值，满足1NF。
2NF（第二范式）
2NF要求消除部分函数依赖。在该关系模式中：
- 主键是 (S#,C#)。
- Sn（姓名）仅依赖于 S#，Cn（课程名）仅依赖于 C#，存在部分函数依赖。
  因此，该关系模式不满足2NF。
3NF（第三范式）
由于不满足2NF，自然也不满足3NF。
BCNF（巴斯-科德范式）
同样，由于不满足2NF，也不满足BCNF。

因此，该关系模式最高满足1NF。

😀 第11题

在C语言中，以下说法不正确的是（）。

A. 在C程序中，整数和实数都能被准确无误地表示出来

B. 在C程序中，任何一个变量名都代表存储器中的⼀个位置

C. 静态变量的生存期与整个程序的运行期相同

D. C语言中，任何变量都必须先声明才能进行引用

题目解析：

A. 在C程序中，整数和实数都能被准确无误地表示出来
不正确。在C语言中，整数通常可以准确表示，但实数（浮点数）由于存储精度的限制，可能无法准确表示某些小数（如0.1）。因此，实数并不总是能被准确无误地表示。

B. 在C程序中，任何一个变量名都代表存储器中的一个位置
正确。变量名是存储器中某个位置的标识符。

C. 静态变量的生存期与整个程序的运行期相同
正确。静态变量的生存期从程序开始运行到程序结束。

D. C语言中，任何变量都必须先声明才能进行引用
正确。C语言要求变量必须先声明后使用。

😀 第12题

⼀个C语言程序是由（）。

A. ⼀个主程序和若干子程序组成 B. 函数组成 C. 若干过程组成 D. 若干子程序组成

题目解析：

C语言程序的基本组成单位是函数。一个C语言程序由一个主函数（main函数）和若干其他函数组成。

A. 一个主程序和若干子程序组成
不准确。C语言中没有“主程序”和“子程序”的概念，而是“函数”。

B. 函数组成
正确。C语言程序由函数组成，包括主函数和其他自定义函数。

C. 若干过程组成
错误。C语言中没有“过程”的概念。

D. 若干子程序组成
错误。C语言中没有“子程序”的概念。

😀 第13题

以下标识符不是关键字的是（）。

A. break B. char C. Switch D. return

题目解析：

在C语言中，关键字（Keywords）是预定义的保留标识符，具有特殊含义，不能用作变量名或函数名。题目要求找出不是关键字的选项。

选项分析：

A. break

是关键字，用于跳出循环或switch语句。

B. char

是关键字，用于声明字符型变量。

C. Switch

不是关键字。C语言的关键字是switch（全小写），而Switch因首字母大写，被视为普通标识符（如变量名或函数名）。

D. return

是关键字，用于从函数返回值。

😀 第14题

下列选项中，不能作为合法常量的是（）。

A. 1.234e04 B. 1.234e0.4 C. 1.234e+4 D. 1.234e0

题目解析：

在C语言中，浮点型常量的科学计数法表示需满足以下规则：

格式：[整数部分].[小数部分]e[指数部分]。
指数部分：必须是整数（可带正负号，如e+4或e-2），不能是小数。

选项分析：

A. 1.234e04

合法。指数部分是整数（04）。

B. 1.234e0.4

不合法。指数部分为0.4（小数），违反科学计数法规则。

C. 1.234e+4

合法。指数部分是整数（+4）。

D. 1.234e0

合法。指数部分是整数（0）。

😀 第15题

以下不合法的用户标识符是（）。

A. r3_t3 B. Else C. 6a D. _6

题目解析：

在C语言中，用户标识符（变量名、函数名等）的命名需遵循以下规则：

组成字符：字母（A-Z/a-z）、数字（0-9）、下划线（_）。
首字符：必须是字母或下划线，不能是数字。
区分大小写：Else与关键字else不同。
不能是关键字：如int、if等（但Else不是关键字）。

选项分析：

A. r3_t3

合法。符合标识符规则（字母开头，含数字和下划线）。

B. Else

合法。虽与关键字else拼写相似，但C语言区分大小写，Else不是关键字。

C. 6a

不合法。以数字开头，违反标识符规则。

D. _6

合法。以下划线开头，符合规则。

😀 第16题

下列叙述中正确的是（）。

A. 调用printf()函数时，必须要有输出项

B. 使用putchar()函数时，必须在之前包含头文件stdio.h

C. 在C语言中，整数可以以二进制、八进制或十六进制的形式输出

D. 调节getchar()函数读入字符时，可以从键盘上输入字符所对应的ASCII码

题目解析：

选项分析：

A. 调用printf()函数时，必须要有输出项

错误。printf()可以没有输出项，例如仅输出字符串：printf("Hello");。

B. 使用putchar()函数时，必须在之前包含头文件stdio.h

正确。putchar()是标准I/O函数，需包含stdio.h头文件，否则编译器可能无法识别。

C. 在C语言中，整数可以以二进制、八进制或十六进制的形式输出

部分错误。C语言支持八进制（%o）和十六进制（%x）输出，但没有直接支持二进制输出的格式符（需手动实现）。

D. 调节getchar()函数读入字符时，可以从键盘上输入字符所对应的ASCII码

错误。getchar()读取的是键盘输入的字符，而非ASCII码值。例如输入字符'A'，返回其ASCII码值（65），但直接输入数字65会被视为字符'6'和'5'。

关键点：

选项B是唯一完全正确的叙述，其他选项均存在错误或不严谨之处。

😀 第17题

执行以下程序段后，w的值为（）。

int w='A', x=14, y=15;
w=((x || y)&&(w<'a'));

A. -1 B. NULL C. 1 D. 0

解题步骤

1. 初始化变量

首先，初始化三个变量：

w = 'A'：字符 'A' 的 ASCII 码值为 65。
x = 14
y = 15

2. 表达式解析

我们需要计算 w = ((x || y) && (w < 'a'))。分步解析：

(1) 计算 (x || y)

|| 是逻辑或运算符。如果 x 或 y 中至少有一个非零，则结果为 1（真），否则为 0（假）。
x = 14（非零），y = 15（非零），因此 (x || y) 的值为 1。

(2) 计算 (w < 'a')

w = 'A'（ASCII 值为 65），'a' 的 ASCII 值为 97。
比较 65 < 97，结果为真（1）。

(3) 计算 (x || y) && (w < 'a')

&& 是逻辑与运算符。如果两边的表达式都为真，则结果为 1，否则为 0。
(x || y) = 1，(w < 'a') = 1，因此 1 && 1 的值为 1。

(4) 赋值给 w

w = 1（将逻辑表达式的结果赋值给 w）。

3. 结果

w 的最终值为 1。

4. 排除其他选项

A. -1：不正确，逻辑运算的结果是 1 或 0，不会出现 -1。
B. NULL：NULL 通常用于指针，此处不适用。
D. 0：不正确，因为 (x || y) 和 (w < 'a') 都为真。

正确答案 C. 1

😀 第18题

设有定义："long x=123450L;"，则以下能够正确输出变量x的是（）。

A. printf("x=%d\n",x); B. printf("x=%id\n",x);

C. printf("x=%dL\n",x); D. printf("x=%ld\n",x);

解题步骤

1. 理解变量类型

x 被定义为 long 类型：long x = 123450L;。
long 是长整型，通常占用 4 字节或 8 字节（取决于系统），其格式化输出需要用 %ld。

2. 分析 printf 的格式化字符串

printf 的格式化字符串需要匹配变量的类型：

%d：用于 int 类型。
%ld：用于 long 类型。
%id：无效的格式说明符（i 不是合法的格式修饰符）。
%dL：L 会被当作普通字符输出，而不是格式说明符的一部分。

3. 逐项验证选项

A. printf("x=%d\n",x);
- 错误：用 %d 输出 long 类型，可能导致截断或未定义行为（尤其是 long 和 int 大小不同时）。
B. printf("x=%id\n",x);
- 错误：%id 是无效的格式说明符（i 无意义）。
C. printf("x=%dL\n",x);
- 错误：%d 不匹配 long 类型，且 L 会被当作普通字符输出（如 x=123450L，但实际是格式不匹配）。
D. printf("x=%ld\n",x);
- 正确：%ld 是 long 类型的标准格式说明符。

4. 关键点

long 类型必须用 %ld 输出，%d 仅适用于 int。
其他选项要么格式不匹配，要么语法错误。

正确答案 D. printf("x=%ld\n",x);

😀 第19题

已有定义int a=3;和输出语句printf("%8x",a);以下正确的叙述是（）。

A. 整型变量的输出格式符只有%d⼀种

B. %x是格式符的⼀种，它可以适用于任何⼀种类型的数据

C. %x是格式符的⼀种，其变量的值按十六进制数输出，但%8x是错误的

D. %8x是正确的格式符，其中数字8规定了输出字段的宽度

解题步骤

1. 分析 printf("%8x", a); 的含义

%x：以十六进制形式输出整数（无符号）。
%8x：以十六进制形式输出整数，且最小字段宽度为 8（不足时左侧补空格）。
a = 3 的十六进制是 3，因此输出为 3（共 8 位，左侧补 7 个空格）。

2. 逐项验证选项

A. 整型变量的输出格式符只有 %d 一种
- 错误。整型变量还可以用 %x（十六进制）、%o（八进制）、%u（无符号十进制）等格式符。
B. %x 是格式符的一种，它可以适用于任何一种类型的数据
- 错误。%x 仅适用于整型（如 int、unsigned int），不能用于浮点型或指针等。
C. %x 是格式符的一种，其变量的值按十六进制数输出，但 %8x 是错误的
- 部分错误。%x 确实按十六进制输出，但 %8x 是正确的（8 是字段宽度修饰符）。
D. %8x 是正确的格式符，其中数字 8 规定了输出字段的宽度
- 正确。%8x 表示十六进制输出，且最小占 8 字符宽度（不足时补空格）。

3. 关键点

%x 用于十六进制输出，%8x 是合法的（8 是宽度修饰符）。
其他选项或片面（A）、或错误（B、C）。

正确答案 D. %8x 是正确的格式符，其中数字 8 规定了输出字段的宽度

😀 第20题

若有定义int x,y; 并已正确给变量赋值，则下列选项中与表达式(x-y)?(x++):(y++)中的条件表达式(x-y)等价的是（）。

A. （x-y>0） B. （x-y<0） C. （x-y<0||x-y>0） D. （x-y==0）

解题步骤

1. 理解条件表达式 (x - y) ? (x++) : (y++)

条件运算符 ? : 的语法：条件 ? 表达式1 : 表达式2。
如果 条件 为真（非零），执行 表达式1；否则（为零），执行 表达式2。
因此，(x - y) 是条件，其逻辑等价于判断 (x - y) 是否为非零。

2. 分析 (x - y) 的真值

(x - y) 是一个数值表达式，其作为条件时：
- 如果 x != y（即 x - y 不为零），则 (x - y) 为真。
- 如果 x == y（即 x - y 为零），则 (x - y) 为假。
因此，(x - y) 的逻辑等价于 (x != y) 或 !(x == y)。

3. 对比选项

A. (x - y > 0)
仅当 x > y 时为真，不完全等价（漏了 x < y 的情况）。
B. (x - y < 0)
仅当 x < y 时为真，不完全等价（漏了 x > y 的情况）。
C. (x - y < 0 || x - y > 0)
等价于 (x != y)，与 (x - y) 的真值完全一致。
D. (x - y == 0)
是 (x - y) 的反义（x == y），不符合。

4. 验证选项C

(x - y < 0 || x - y > 0) 表示 x < y 或 x > y，即 x != y。
这与 (x - y) 的条件逻辑完全一致：
- x != y 时，(x - y) 非零（真）；
- x == y 时，(x - y) 为零（假）。

5. 排除其他选项

A、B 只覆盖部分情况；
D 是反向逻辑；
C 是唯一完全等价的选项。

正确答案 C. (x - y < 0 || x - y > 0)

😀 第21题

若a、b、c、d都是int型变量且都已经正确赋初值，则以下不正确的赋值语句是（）。

A. a+d; B. a++; C. a=b=c=d=100; D. a=(b=3)+(d=5);

解题步骤

1. 理解“赋值语句”的定义

在C语言中，赋值语句是指对变量赋予新值的语句，通常包含赋值运算符（=、+=、++ 等）。
若语句不改变任何变量的值，则不属于赋值语句。

2. 逐项分析选项

A. a+d;
- 这是一个表达式语句，计算 a + d 的值，但未将结果赋值给任何变量。
- 虽然语法合法，但不是赋值语句（题目要求找“不正确的赋值语句”，因此它不符合赋值语句的定义）。
- 如果题目问的是“语法错误”，A是合法的；但问的是“不正确的赋值语句”，A是正确答案。
B. a++;
- 这是赋值语句，等价于 a = a + 1;。
- 语法和逻辑均正确。
C. a=b=c=d=100;
- 这是链式赋值，从右向左依次赋值：d=100 → c=d → b=c → a=b。
- 语法和逻辑均正确。
D. a=(b=3)+(d=5);
- 这是合法的赋值语句：先执行 b=3 和 d=5，再计算 3 + 5 并赋值给 a。
- 语法和逻辑均正确。

3. 关键点

题目问的是**“不正确的赋值语句”**，而非“语法错误”。
a+d; 是表达式语句，未对任何变量赋值，因此不符合赋值语句的定义。
其他选项（B、C、D）均明确修改了变量的值，属于赋值语句。

4. 排除法

如果题目问的是“语法错误”，则所有选项均合法；
但问的是“不正确的赋值语句”，只有 A 不是赋值语句。

正确答案 A. a+d;（因为它不是赋值语句，而题目要求找“不正确的赋值语句”。）

😀 第22题

有以下程序

#define F(X,Y)(X)*(Y)
int main()
{
    int a=3, b=4;
    printf("%d\n", F(a++, b++));
}

程序运行后的输出结果是（）。

A. 12 B. 15 C. 16 D. 20

解题步骤

1. 宏展开

宏 F(X,Y) 定义为 (X)*(Y)，因此 F(a++, b++) 会被展开为：

(a++) * (b++)

2. 表达式求值

a++ 是后置自增，先使用 a 的值，再自增。
b++ 同理，先使用 b 的值，再自增。

因此，表达式 (a++) * (b++) 的计算过程如下：

取 a 的当前值（3）和 b 的当前值（4），计算 3 * 4 = 12。
然后 a 自增为 4，b 自增为 5。

3. 输出结果

printf 输出的是 (a++) * (b++) 的计算结果，即 12。

4. 验证选项

A. 12：正确。
B. 15：错误。
C. 16：错误。
D. 20：错误。

5. 关键点

宏是直接替换，因此 F(a++, b++) 展开为 (a++) * (b++)。
后置自增的特性是先取值后自增，因此乘法运算使用的是 a=3 和 b=4。

正确答案 A. 12

😀 第23题

下面程序的输出结果是（）。

int main()
{
    int a[10]={1,2,3,4,5,6,7,8,9,10},*p=a;
    printf("%d\n",*(p+2));
}

A. 3 B. 4 C. 1 D. 2

解题步骤

1. 理解指针和数组的关系

int a[10] = {1, 2, 3, ..., 10}; 定义了一个整型数组 a，包含 10 个元素。
int *p = a; 定义了一个指针 p，并指向数组 a 的首地址（即 a[0] 的地址）。

2. 指针运算

p + 2 表示指针 p 向后移动 2 个 int 的位置（因为 p 是 int* 类型）。
- p 指向 a[0]，p + 1 指向 a[1]，p + 2 指向 a[2]。
*(p + 2) 是解引用操作，获取 p + 2 指向的值，即 a[2] 的值。

3. 数组下标对应值

a[0] = 1, a[1] = 2, a[2] = 3, ..., a[9] = 10。
因此，*(p + 2) 的值是 a[2] = 3。

4. 输出结果

printf 输出 *(p + 2) 的值，即 3。

5. 验证选项

A. 3：正确。
B. 4：错误（a[3] 的值）。
C. 1：错误（a[0] 的值）。
D. 2：错误（a[1] 的值）。

正确答案 A. 3

😀 第24题

有以下程序：

#include<stdio.h>
int main()
{
    int a=6,b=7,m=1;
    switch(a%2)
    {
        case 0:m++;break;
        case 1:m++;
        switch(b%2)
        {
            defaut:m++;
            case0:m++;break;
        }
    }
    printf("%d\n",m);
}

程序运行后的输出结果是（）。

A. 1 B. 2 C. 3 D. 4

解题步骤

1. 理解变量初始值

a = 6, b = 7, m = 1。

2. 外层 switch(a % 2) 分析

a % 2 计算 6 % 2，结果为 0。
执行 case 0: 分支：
- m++：m 从 1 增加到 2。
- break：跳出外层 switch，不会执行 case 1 分支。

3. 关键点

由于 a % 2 == 0，直接执行 case 0 分支，m 变为 2 后跳出 switch。
内层 switch(b % 2) 不会被执行（因为外层 case 0 有 break）。

4. 输出结果

printf 输出 m 的最终值：2。

5. 验证选项

A. 1：错误（m 至少会自增一次）。
B. 2：正确。
C. 3：错误（需要执行内层 switch 才会达到）。
D. 4：错误。

正确答案 B. 2

😀 第25题

有以下程序

#include <stdio.h>

int fun(int a, int b) {
    if (b == 0) return a;
    else return (fun(--a, --b));
}

int main() {
    printf("%d\n", fun(4, 2));
}

程序的运行结果是（）。

A. 1 B. 2 C. 3 D. 4

解题步骤

1. 理解递归函数 fun(a, b)

函数 fun(a, b) 的逻辑：

基线条件（Base Case）：如果 b == 0，直接返回 a。
递归条件：否则，返回 fun(--a, --b)（先对 a 和 b 自减，再递归调用）。

2. 递归调用过程

计算 fun(4, 2) 的详细过程：

第一次调用：fun(4, 2)
- b = 2 != 0，执行 else 分支。
- 先计算 --a 和 --b，得到 a = 3, b = 1。
- 递归调用 fun(3, 1)。
第二次调用：fun(3, 1)
- b = 1 != 0，执行 else 分支。
- 先计算 --a 和 --b，得到 a = 2, b = 0。
- 递归调用 fun(2, 0)。
第三次调用：fun(2, 0)
- b = 0，满足基线条件，直接返回 a = 2。

3. 返回值回溯

fun(2, 0) 返回 2 → fun(3, 1) 返回 2 → fun(4, 2) 返回 2。
最终 main() 中 printf 输出 2。

4. 关键点

递归的终止条件是 b == 0，此时返回当前的 a。
每次递归调用前，a 和 b 都会先自减 1。
递归的最终结果是 a 的初始值 4 减去 b 的初始值 2，即 4 - 2 = 2。

5. 验证选项

A. 1：错误。
B. 2：正确。
C. 3：错误。
D. 4：错误。

正确答案 B. 2

😀 第26题

关于字符常量，以下叙述正确的是（）。

A. 空格不是⼀个字符常量 B. 字符常量能包含大于⼀个的字符

C. 单引号中的大写字母和小写字母代表的是相同的字符常量

D. 所有的字符常量都可以作为整型量来处理

解题步骤

1. 理解字符常量的定义

在C语言中，字符常量是用单引号括起来的单个字符，例如 'A'、' '（空格）、'1' 等。
字符常量在内存中以对应的ASCII码值存储（如 'A' 的值为65），因此可以参与整数运算。

2. 逐项分析选项

A. 空格不是一个字符常量
- 错误。空格是一个字符常量，表示为 ' '（单引号内有一个空格）。
B. 字符常量能包含大于一个的字符
- 部分错误。标准C语言中，字符常量严格定义为单个字符（如 'a'）。
- 但某些编译器支持多字符常量（如 'ab'），其值是依赖实现的（非标准），通常不建议使用。
C. 单引号中的大写字母和小写字母代表的是相同的字符常量
- 错误。大写和小写字母的ASCII码不同（如 'A' 是65，'a' 是97），它们是不同的字符常量。
D. 所有的字符常量都可以作为整型量来处理
- 正确。字符常量本质是整数（ASCII码值），因此可以像整数一样参与运算（如 'A' + 1 得到 66）。

3. 关键点

字符常量的本质：是整数（ASCII码），因此选项D正确。
空格：是合法的字符常量（' '），选项A错误。
大小写字母：ASCII码不同，选项C错误。
多字符常量：非标准特性，选项B不严谨。

4. 排除法

A、B、C均有明显错误或局限性，只有D完全正确。

正确答案 D. 所有的字符常量都可以作为整型量来处理

😀 第27题

下面函数调用语句含有实参的个数为（）。

func((exp1,exp2),(exp3,exp4,exp5));

A. 1 B. 2 C. 3 D. 5

解题步骤

1. 理解逗号运算符

在C语言中，逗号运算符（,） 用于分隔表达式，并返回最后一个表达式的值。例如：

(exp1, exp2) 的值是 exp2。
(exp3, exp4, exp5) 的值是 exp5。

2. 分析函数调用的实参

函数 func 的参数列表如下：

func((exp1, exp2), (exp3, exp4, exp5));

根据逗号运算符的特性：

第一个参数 (exp1, exp2) 的值是 exp2。
第二个参数 (exp3, exp4, exp5) 的值是 exp5。

因此，实际传递给 func 的实参是 exp2 和 exp5，共 2个实参。

3. 验证选项

A. 1：错误（忽略了第二个括号内的逗号运算）。
B. 2：正确（exp2 和 exp5）。
C. 3：错误（误将 exp3、exp4、exp5 都当作独立参数）。
D. 5：错误（误将 exp1 到 exp5 都当作独立参数）。

4. 关键点

逗号运算符会将多个表达式合并为一个表达式，最终只返回最后一个表达式的值。
函数调用的实参个数取决于最外层的逗号分隔，这里只有 (exp1,exp2) 和 (exp3,exp4,exp5) 两部分。

正确答案 B. 2

😀 第28题

语句int(*ptr)()的含义是（）。

A. ptr是⼀个返回值是int的函数

B. ptr是指向int型数据的指针变量

C. ptr是指向函数的指针，该函数返回⼀个int型数据

D. ptr是⼀个函数名，该函数的返回值是指向int型数据的指针

解题步骤

1. 理解 int (*ptr)(); 的语法

int (*ptr)(); 是一个函数指针的声明。
分解语法：
- *ptr：ptr 是一个指针。
- (*ptr)()：ptr 指向一个函数（括号表示函数调用）。
- int (*ptr)();：ptr 指向的函数返回 int 类型。

2. 排除错误选项

A. ptr 是一个返回值是 int 的函数
- 错误。ptr 是指针，不是函数本身。
B. ptr 是指向 int 型数据的指针变量
- 错误。ptr 指向函数，而非 int 数据。
D. ptr 是一个函数名，该函数的返回值是指向 int 型数据的指针
- 错误。ptr 是指针，不是函数名；且它指向的函数返回 int，而非 int*。

3. 正确选项

C. ptr 是指向函数的指针，该函数返回一个 int 型数据
- 正确。ptr 是函数指针，指向的函数返回 int。

4. 关键点

int (*ptr)(); 是函数指针的经典声明。
对比 int *ptr();（返回 int* 的函数声明），注意括号的位置差异。

正确答案 C. ptr 是指向函数的指针，该函数返回一个 int 型数据

😀第29题

以下不正确的定义语句是（）。

A. double x[5]={1.0,2.0,3.0,4.0,5.0}; B. int y[5]={0,1,2,3,4,5};

C. char c1[]={'1', '2', '3', '4', '5'}; D. char c2[]={'a', 'b', 'c'};

解题步骤

1. 理解数组定义和初始化的规则

在C语言中，数组的定义和初始化需遵循以下规则：

数组大小可以显式指定（如 int a[5]），或通过初始化列表隐式确定（如 int a[] = {1, 2}）。
初始化的元素数量不能超过数组大小。例如 int a[2] = {1, 2, 3}; 是错误的。
如果初始化列表的元素少于数组大小，剩余元素默认初始化为 0（或 '\0' 对于字符数组）。

2. 逐项分析选项

A. double x[5] = {1.0, 2.0, 3.0, 4.0, 5.0};
- 正确。数组大小为 5，初始化列表恰好有 5 个 double 值。
B. int y[5] = {0, 1, 2, 3, 4, 5};
- 不正确。数组 y 的大小为 5，但初始化列表有 6 个元素（0, 1, 2, 3, 4, 5），超出数组容量。
C. char c1[] = {'1', '2', '3', '4', '5'};
- 正确。数组大小未显式指定，根据初始化列表隐式确定为 5。
D. char c2[] = {'a', 'b', 'c'};
- 正确。数组大小隐式确定为 3。

3. 关键点

选项B是唯一违反数组初始化规则的语句（初始化元素数量 > 数组大小）。
其他选项均符合语法规则。

4. 常见陷阱

注意隐式确定数组大小时，初始化列表的元素数量必须与数组大小匹配（如选项B显式指定了大小 [5]，但给了 6 个值）。
字符数组的初始化可以用字符列表（如选项C、D），但需注意是否包含字符串终止符 '\0'（本题不涉及此问题）。

正确答案 B. int y[5] = {0, 1, 2, 3, 4, 5};

😀 第30题

若有以下定义，则对数组元素的正确引用是（）。

int a[5],*p=a;

A. *&a[5] B. (*a)+2 C. *p+4 D. *(a+2)

解题步骤

1. 理解数组和指针的定义

int a[5]：定义一个包含 5 个整数的数组 a，元素为 a[0] 到 a[4]。
int *p = a：定义指针 p 并指向数组 a 的首地址（即 &a[0]）。

2. 数组元素的引用方式

数组元素可以通过以下方式引用：

下标法：a[i]（i 从 0 到 4）。
指针法：
- *(a + i)：等价于 a[i]。
- *(p + i)：等价于 p[i]。

3. 逐项分析选项

A. *&a[5]
- a[5]：越界访问（数组下标范围为 0 到 4）。
- &a[5] 是合法的地址（指向 a[4] 的下一个位置），但解引用 *&a[5] 是未定义行为。
- 错误。
B. (*a)+2
- *a 等价于 a[0]（数组首元素的值）。
- (*a)+2 是 a[0] + 2，不是对数组元素的引用，而是对值的运算。
- 错误。
C. *p+4
- *p 等价于 a[0]（p 指向 a[0]）。
- *p+4 是 a[0] + 4，不是对数组元素的引用，而是对值的运算。
- 错误。
D. *(a+2)
- a+2 是 &a[2]（第 3 个元素的地址）。
- *(a+2) 等价于 a[2]，是对数组元素的正确引用。
- 正确。

4. 关键点

数组元素的引用必须直接或间接指向某个元素（如 a[i] 或 *(a+i)）。
选项 B 和 C 是对元素值的运算，而非引用元素本身。
选项 A 是越界访问。

5. 排除法

A 越界，B 和 C 是运算，只有 D 是合法的元素引用。

正确答案 D. *(a+2)

😀 第31题

下列字符数组初始化语句中，不正确的是（）。

A. char c[]='goodmorning';

B. char c[20]= "goodmorning";

C. char c[]={'a','b','c','d'};

D. char c[]={"goodmorning"};

解题步骤

1. 理解字符数组的初始化规则

在C语言中，字符数组可以通过以下方式初始化：

用字符串字面量初始化：
- 语法：char c[] = "string"; 或 char c[N] = "string";。
- 字符串字面量会自动在末尾添加 '\0'（空字符）。
用字符列表初始化：
- 语法：char c[] = {'a', 'b', 'c'};。
- 不会自动添加 '\0'，除非显式包含（如 {'a', 'b', '\0'}）。

2. 逐项分析选项

A. char c[] = 'goodmorning';
- 错误：
  - 单引号 '' 用于表示单个字符（如 'g'），不能包裹多个字符。
  - 正确写法应为双引号 ""：char c[] = "goodmorning";。
B. char c[20] = "goodmorning";
- 正确：
  - 数组大小为 20，字符串 "goodmorning"（长度 10 + '\0'）可以完全存入，剩余元素自动填充 '\0'。
C. char c[] = {'a', 'b', 'c', 'd'};
- 正确：
  - 隐式确定数组大小为 4，初始化为字符列表（无 '\0'）。
D. char c[] = {"goodmorning"};
- 正确：
  - 等价于 char c[] = "goodmorning";，花括号 {} 可省略。

3. 关键点

选项A的错误在于混淆了字符常量（单引号）和字符串字面量（双引号）。
其他选项均符合字符数组初始化的语法规则。

4. 常见陷阱

单引号 '' 只能用于单个字符（如 'a'），多字符会触发编译器警告或错误。
双引号 "" 用于字符串，会自动添加 '\0'。

正确答案 A. char c[] = 'goodmorning';

😀 第32题

下列程序的运行结果为（）。

#include<stdio.h>

void abc(char *str) {
    int a, b, i, j;
    for (i = j = 0; str[i] != '\0'; i++) {
        if (str[i] != 'a') {
            str[j++] = str[i];
        }
    }
    str[j] = '\0';
}

void main() {
    char str[] = "abcdef";
    abc(str);
    printf("str[]=%s", str);
}

A. str[]=bcdef B. str[]=abcdef C. str[]=a D. str[]=ab

解题步骤

1. 理解函数 abc 的功能

函数 abc(char *str) 的作用是过滤字符串中的字符 'a'，具体逻辑如下：

初始化两个指针 i 和 j（均从 0 开始）。
遍历字符串 str（直到遇到 '\0'）：
- 如果当前字符 str[i] 不是 'a'，则将其复制到 str[j] 并递增 j。
- 如果当前字符是 'a'，则跳过（不复制）。
最后在 str[j] 处添加字符串结束符 '\0'。

2. 分析字符串处理过程

初始字符串："abcdef"（即 {'a', 'b', 'c', 'd', 'e', 'f', '\0'}）。

遍历过程：
- i=0：str[0]='a' → 跳过，j=0。
- i=1：str[1]='b' → 复制到 str[0]，j=1。
- i=2：str[2]='c' → 复制到 str[1]，j=2。
- i=3：str[3]='d' → 复制到 str[2]，j=3。
- i=4：str[4]='e' → 复制到 str[3]，j=4。
- i=5：str[5]='f' → 复制到 str[4]，j=5。
- i=6：str[6]='\0' → 循环结束。
结果字符串：
- 复制后的字符序列：{'b', 'c', 'd', 'e', 'f', '\0'}。
- 最终 str 的内容为 "bcdef"。

3. 输出结果

printf 输出 str[]=bcdef。

4. 验证选项

A. str[]=bcdef：正确。
B. str[]=abcdef：错误（未过滤 'a'）。
C. str[]=a：错误（逻辑完全不符）。
D. str[]=ab：错误（未体现过滤过程）。

5. 关键点

函数 abc 的核心逻辑是原地删除字符 'a'，其他字符前移。
j 始终指向新字符串的当前位置，i 遍历原字符串。

正确答案 A. str[]=bcdef

😀 第33题

阅读下面程序，程序执行后的结果为（）。

#include "stdio.h"
int main() {
    char *str = "abcdefghijklmnopq";
    while (*str++ != 'e');
    printf("%c\n", *str);
}

A. f B. a C. e D. q

解题步骤

1. 理解指针和字符串

char *str = "abcdefghijklmnopq";：str 是一个指针，指向字符串常量 "abcdefghijklmnopq" 的首字符 'a'。
字符串在内存中的布局：'a', 'b', 'c', 'd', 'e', 'f', ..., 'q', '\0'。

2. 分析 while 循环

while (*str++ != 'e'); 的执行过程：
1. *str++ 的运算顺序：
  - 先取 *str 的值（当前字符），再执行 str++（指针后移）。
2. 循环终止条件：
  - 当 *str 为 'e' 时，str 已经指向 'e' 的下一个字符 'f'（因为 str++ 已执行）。
3. 具体步骤：
  - 初始：str 指向 'a'，比较 'a' != 'e' → str 指向 'b'。
  - 比较 'b' != 'e' → str 指向 'c'。
  - 比较 'c' != 'e' → str 指向 'd'。
  - 比较 'd' != 'e' → str 指向 'e'。
  - 比较 'e' != 'e'（不成立），循环结束，此时 str 指向 'f'（因为 str++ 已执行）。

3. printf 的输出

循环结束后，str 指向 'f'，因此 printf("%c\n", *str); 输出 'f'。

4. 验证选项

A. f：正确。
B. a：错误（初始字符，但指针已移动）。
C. e：错误（str 已跳过 'e'）。
D. q：错误（指针未遍历到末尾）。

5. 关键点

*str++ 是先取值后自增，因此循环结束时 str 指向目标字符 'e' 的下一个字符 'f'。
如果写成 while (*++str != 'e');，则 str 会指向 'e' 本身。

正确答案 A. f

😀 第34题

设有如下的程序段：

char str[]="HelloWorld";char*ptr;ptr=str;

执行上面的程序段后， *(ptr+10)的值为（）。

A. '\0' B. '0' C. 不确定的值 D. '0'的地址

解题步骤

1. 理解字符串和指针的初始化

char str[] = "HelloWorld";：
- 定义并初始化一个字符数组 str，内容为 "HelloWorld"。
- 字符串字面量 "HelloWorld" 在内存中的布局：'H', 'e', 'l', 'l', 'o', 'W', 'o', 'r', 'l', 'd', '\0'。
- 因此，str 的大小为 11（10个字符 + 1个终止符 '\0'）。
char *ptr; ptr = str;：
- 定义指针 ptr 并指向 str 的首地址（即 &str[0]）。

2. 计算 *(ptr+10) 的值

ptr 指向 str[0]，ptr+10 指向 str[10]。
str[10] 是字符串的第 11 个元素（下标从 0 开始），即字符串的终止符 '\0'。
因此，*(ptr+10) 的值为 '\0'。

3. 验证选项

A. '\0'：正确（字符串的终止符）。
B. '0'：错误（字符 '0' 的ASCII码为 48，与 '\0' 不同）。
C. 不确定的值：错误（字符串明确以 '\0' 结尾）。
D. '0'的地址：错误（*(ptr+10) 是值，不是地址）。

4. 关键点

字符串字面量 "HelloWorld" 隐式包含终止符 '\0'，因此 str[10] 是 '\0'。
*(ptr+10) 等价于 ptr[10] 或 str[10]。

正确答案 A. '\0'

😀 第35题

下述语句中，在字符串s1和s2相等时显示"they are Equal"的是（）。

A. if(*s1==*s2) puts("they are Equal");

B. if(!strcmp(s1,s2)) puts("they are Equal");

C. if(s1==s2) Puts("they are Equal");

D. if(strcmp(s1,s2)) puts("they are Equal");

解题步骤

1. 理解字符串比较的规则

在C语言中：

字符串内容比较需要使用 strcmp(s1, s2) 函数：
- 若 s1 和 s2 内容相同，strcmp 返回 0。
- 若 s1 字典序大于 s2，返回正整数。
- 若 s1 字典序小于 s2，返回负整数。
直接比较指针（如 s1==s2）：仅比较地址是否相同，而非内容。

2. 逐项分析选项

A. if(*s1==*s2) puts("they are Equal");
- 错误：*s1 和 *s2 是比较两个字符串的首字符，而非整个字符串。
B. if(!strcmp(s1,s2)) puts("they are Equal");
- 正确：strcmp(s1,s2)==0 时表示字符串相等，!0 为真，触发输出。
C. if(s1==s2) puts("they are Equal");
- 错误：比较的是指针地址，即使内容相同，若地址不同（如不同数组），结果也为假。
D. if(strcmp(s1,s2)) puts("they are Equal");
- 错误：strcmp 返回 0 时表示相等，但 if(0) 为假，逻辑反了。

3. 关键点

strcmp 的返回值：相等时返回 0，因此条件应为 !strcmp(s1,s2) 或 strcmp(s1,s2)==0。
选项B是唯一正确判断字符串内容相等的写法。

4. 常见陷阱

直接比较指针（选项C）是新手常见错误。
混淆 strcmp 的返回值逻辑（选项D）。

正确答案 B. if(!strcmp(s1,s2)) puts("they are Equal");

😀 第36题

在⼀个C源程序文件中，定义一个只允许本源文件中所有函数使用的全局变量的存储类别是

（）。

A. extern B. static C. register D. auto

解题步骤

1. 理解题目要求

题目要求定义一个全局变量，但其作用范围仅限于当前源文件（即其他源文件无法访问）。这种变量需要具有文件作用域和内部链接性。

2. 分析存储类别的特性

A. extern：
- 用于声明在其他文件中定义的全局变量（扩展作用域）。
- 不限制变量的链接性，无法实现“仅当前文件使用”。
- 不符合要求。
B. static：
- 当用于全局变量时，将其链接性限制为内部链接（仅当前文件可见）。
- 其他文件即使使用 extern 也无法访问该变量。
- 完全符合要求。
C. register：
- 建议编译器将变量存储在寄存器中（仅用于局部变量，不改变作用域或链接性）。
- 不适用。
D. auto：
- 默认的局部变量存储类别（自动存储期），不能用于全局变量。
- 不适用。

3. 关键点

static 修饰全局变量：
将变量的作用域限制在当前文件内，实现“文件私有”全局变量。
其他选项或无法限制作用域（extern），或根本不适用（register、auto）。

4. 示例代码

// file1.c
static int fileLocalVar = 42; // 仅当前文件可见

void func1() {
    fileLocalVar++; // 可访问
}

// file2.c
extern int fileLocalVar; // 错误！无法访问其他文件的 static 全局变量

正确答案 B. static

😀 第37题

以下程序的输出结果是（）。

#include <stdio.h>

void prt(int *x, int *y, int *z) {
    printf("%d,%d,%d\n", ++*x, ++*y, *(z++));
}

int main() {
    int a = 10, b = 40, c = 20;
    prt(&a, &b, &c);
    prt(&a, &b, &c);
}

A. 11,42,31 12,22,41 B. 11,41,20 12,42,20

C. 11,21,40 11,21,21 D. 11,41,21 12,42,22

解题步骤

1. 理解函数 prt 的行为

函数 prt 接收三个指针参数 x、y、z，并在 printf 中执行以下操作：

++*x：对 *x（即 a）先自增，再取值。
++*y：对 *y（即 b）先自增，再取值。
*(z++)：先取 *z（即 c）的值，再对指针 z 自增（不影响 c 的值）。

2. 第一次调用 prt(&a, &b, &c)

初始值：a=10, b=40, c=20。
++*x：a 自增为 11，取值 11。
++*y：b 自增为 41，取值 41。
*(z++)：取 *z（c=20），然后 z 指针自增（不影响 c）。
输出：11,41,20。
此时变量值：a=11, b=41, c=20。

3. 第二次调用 prt(&a, &b, &c)

当前值：a=11, b=41, c=20。
++*x：a 自增为 12，取值 12。
++*y：b 自增为 42，取值 42。
*(z++)：取 *z（c=20），然后 z 指针自增（不影响 c）。
输出：12,42,20。
此时变量值：a=12, b=42, c=20。

4. 关键点

*(z++) 是先取值后指针自增，因此两次调用均输出 c 的原始值 20。
++*x 和 ++*y 直接修改了 a 和 b 的值，因此第二次调用时的值会递增。

5. 验证选项

B：11,41,20 12,42,20 与我们的分析完全一致。
其他选项：
- A：c 的值错误（应为 20）。
- C：b 的值错误（应为 41,42）。
- D：c 的值错误（应为 20）。

正确答案 B. 11,41,20 12,42,20

😀 第38题

设有以下说明，则不正确的叙述是（）。

union un{int a;char b;float c;}arr;

A. arr所占的内存长度等于成员c的长度 B. arr的地址和它的各成员的地址都是同⼀地址

C. arr可以作为函数参数 D. 不能在定义arr时对它初始化

解题步骤

1. 理解联合体（union）的特性

联合体 union 的所有成员共享同一块内存空间，其大小为最大成员的大小。具体特性：

内存共享：所有成员的地址相同（即联合体的地址）。
内存大小：由最大成员决定（如 int、float 通常为 4 字节，char 为 1 字节）。
初始化：可以在定义时初始化，但只能初始化第一个成员。
函数参数：联合体可以作为函数参数传递。

2. 逐项分析选项

A. arr 所占的内存长度等于成员 c 的长度
- 正确。联合体的大小由最大成员决定（假设 float c 是最大成员，通常为 4 字节）。
B. arr 的地址和它的各成员的地址都是同一地址
- 正确。联合体的所有成员共享同一内存地址。
C. arr 可以作为函数参数
- 正确。联合体可以像普通变量一样作为函数参数传递。
D. 不能在定义 arr 时对它初始化
- 不正确。联合体可以在定义时初始化，但只能初始化第一个成员。例如：
  
  union un arr = {10}; // 初始化第一个成员 a

3. 关键点

选项D的表述过于绝对。联合体可以在定义时初始化（只是限制较多）。
其他选项均符合联合体的特性。

4. 常见误区

联合体的初始化只能针对第一个成员，但题目未明确说明初始化内容，因此“不能初始化”是错误的。

正确答案 D. 不能在定义 arr 时对它初始化

🤞 第39题

若x=4，y=5，则x&y的结果是（）。

A. 0 B. 4 C. 3 D. 5

解题步骤

1. 理解按位与运算（&）

按位与运算的规则是对两个数的二进制表示逐位进行逻辑与操作：

1 & 1 = 1
1 & 0 = 0
0 & 1 = 0
0 & 0 = 0

2. 将 x 和 y 转换为二进制

x = 4 的二进制表示：0100
y = 5 的二进制表示：0101

3. 逐位计算 x & y

0100 (4)
& 0101 (5)
----
0100 (4)

从右到左逐位计算：
- 第0位：0 & 1 = 0
- 第1位：0 & 0 = 0
- 第2位：1 & 1 = 1
- 第3位：0 & 0 = 0
结果：0100（十进制 4）。

4. 验证选项

A. 0：错误。
B. 4：正确。
C. 3：错误（0100 & 0101 不可能得到 0011）。
D. 5：错误。

5. 关键点

按位与运算的结果是逐位比较后的二进制值，不是简单的数学加减。
4 & 5 的二进制结果为 0100（即十进制 4）。

正确答案 B. 4

🤞 第40题

下列关于C语言数据文件的叙述中正确的是（）。

A. 文件由ASCII码字符序列组成，C语言只能读写文本文件

B. 文件由二进制数据序列组成，C语言只能读写二进制文件

C. 文件件由记录序列组成，可按数据的存放形式分为二进制文件和文本文件

D. 文件由数据流形式组成，可按数据的存放形式分为二进制文件和文本文件

解题步骤

1. 理解C语言中文件的基本概念

在C语言中，文件被看作是一个数据流（stream），可以是：

文本文件：由可读的ASCII字符组成，每行以换行符结束。
二进制文件：由二进制数据直接存储，无格式转换。

2. 分析选项

A. 文件由ASCII码字符序列组成，C语言只能读写文本文件
- 错误：C语言可以处理二进制文件（如 fopen 使用 "rb" 模式），且文件内容不限于ASCII字符。
B. 文件由二进制数据序列组成，C语言只能读写二进制文件
- 错误：C语言也能读写文本文件（如 "r" 模式），且文本文件本质也是二进制存储（但内容可读）。
C. 文件由记录序列组成，可按数据的存放形式分为二进制文件和文本文件
- 部分错误：
  - “记录序列”是特定数据结构的描述（如数据库），不适用于普通文件。
  - 文件分类正确，但前提描述不准确。
D. 文件由数据流形式组成，可按数据的存放形式分为二进制文件和文本文件
- 正确：
  - C语言将文件视为数据流（stream），分类为文本/二进制文件。
  - 文本文件：字符流；二进制文件：原始字节流。

3. 关键点

数据流（stream）是C语言对文件的抽象，与具体存储形式无关。
文本文件和二进制文件的区别在于数据解释方式，而非物理存储。

4. 排除法

A、B 过于片面（忽略另一种文件类型）。
C 的“记录序列”不准确。
D 的描述完全符合C语言标准。

正确答案 D. 文件由数据流形式组成，可按数据的存放形式分为二进制文件和文本文件

🤞 第41题

给定程序中，函数fun的功能是用函数指针指向要调用的函数，并进行调用。规定在__2__处使fa指向函数f1，在__3__处使fb指向函数f2。当调用正确时，程序输出：

x1=5.000000，x2=3.000000，x1*x1+x1*x2=40.000000

请在程序的下划线处填入正确的内容并把下划线删除，使程序得出正确的结果。

注意：源程序存放在考生文件夹下的BLANK.C中。

不得增行或删行，也不得更改程序的结构！

给定源程序：

🤞 1. 正确答案： double 2. 正确答案： f1 3. 正确答案： f2

在给定的代码中，r1 和 r2 对函数指针 f 的使用方式不同：

r1 = f(a); 直接调用 f。
r2 = (*f)(a, b); 通过 *f 调用 f。

原因解释

函数指针的两种调用方式：
- C语言中，函数指针可以通过两种方式调用：
  - 直接调用：f(a)，编译器会自动解引用。
  - 显式解引用：(*f)(a, b)，通过 * 显式解引用函数指针。
- 两种方式在功能上是等价的，只是语法不同。
代码中的不一致性：
- 在 r1 = f(a); 中，直接使用 f 调用 f1（编译器隐式处理）。
- 在 r2 = (*f)(a, b); 中，显式使用 *f 调用 f2，可能是为了强调 f 是一个指针。
历史习惯与代码风格：
- 早期C代码中，显式解引用（(*f)()）更常见，用于明确表示 f 是指针。
- 现代C标准允许直接调用（f()），因为函数名本身也会被转换为函数指针。
实际效果：
- 无论是否使用 *，函数调用的结果完全相同。
- 例如：
  - f(a) 和 (*f)(a) 是等价的。
  - f(a, b) 和 (*f)(a, b) 也是等价的。