深圳大学 C 语言期末试卷解析与模拟卷（完整修订版）

说明：本卷包括 2023 和 2024 年两套期末试卷的完整原题、逐题解析、答案，以及两套模拟卷。原卷为扫描版 PDF，经 OCR 提取后存在少量错字，以下内容已校正。若个别字符与原图略有出入，以原卷图片为准。

修订记录：

• 修正 2024 卷选择题第 7 题答案（原 OCR 答案有误）
• 修正 2024 卷程序阅读题第 9 题解析与答案
• 修正 2024 卷选择题第 18 题解析说明
• 统一所有【解答】格式，补充缺失的选项字母
• 对 gets() 等已废弃函数添加安全提示
• 优化代码格式与注释

第一部分：2023 期末试卷（B 卷）逐题解析

一、单项选择题（每小题 1 分，共 30 分）

1

题目：C 语言是一种：（ ）
A. 高级语言 B. 低级语言 C. 机器语言 D. 脚本语言

解析：C 语言属于高级语言，兼具底层操作能力，但本质上是高级语言。
答案：A. 高级语言

2

题目：void 函数表示该函数：（ ）
A. 没有返回值 B. 返回任何类型 C. 返回 void 类型 D. 没有意义

解析：void 作为函数返回类型表示该函数不返回任何值。
答案：A. 没有返回值

3

题目：下列哪个语句可以用于输出一个整数 n？（ ）
A. printf("%d", &n); B. printf("%d", n); C. print(n); D. printf(n);

解析：输出整数应使用格式符 %d，并传入变量本身（而非地址）。print 不是 C 标准函数。
答案：B. printf("%d", n);

4

题目：下列哪个运算符可以用来获取变量的地址？（ ）
A. * B. $ C. # D. &

解析：& 是取地址运算符；* 是解引用运算符。
答案：D. &

5

题目：下面声明数组有错误的是：（ ）
A. int a[10]; B. float b[5]; C. char c[] = "abc"; D. int d[0];

解析：C 语言标准规定数组长度必须大于 0，int d[0]; 属于错误声明（某些编译器扩展允许，但标准禁止）。
答案：D. int d[0];

6

题目：i += 2; 与 i = i + 2; 的关系是：（ ）
A. 等价 B. 不等价 C. 依赖编译器 D. i += 2 语法错误

解析：复合赋值运算符 += 与展开形式完全等价。
答案：A. 等价

7

题目：下列哪个关键字可以用于声明一个自动变量？（ ）
A. static B. extern C. auto D. register

解析：auto 用于声明自动变量（局部变量默认即为 auto，通常省略）。
答案：C. auto

8

题目：下列哪个关键字用于定义一个数据类型的别名？（ ）
A. typedef B. struct C. union D. enum

解析：typedef 用于为已有类型创建新名称（别名）。
答案：A. typedef

9

题目：判断 char 型变量 c1 是否为小写字母的正确表达方式是：（ ）
A. 'a' <= c1 <= 'z' B. (c1 >= a) && (c1 <= z)
C. ('a' >= c1) || ('z' <= c1) D. (c1 >= 'a') && (c1 <= 'z')

解析：C 语言不支持链式比较（如 a <= b <= c），必须写成两个条件用逻辑与 && 连接；字符常量需加单引号。
答案：D. (c1 >= 'a') && (c1 <= 'z')

10

题目：下列哪个格式化字符可以用于打印一个字符？（ ）
A. %c B. %d C. %E D. %s

解析：%c 用于输出单个字符；%s 用于输出字符串。
答案：A. %c

11

题目：若有整数 x 的定义，下列哪个 switch 语句的语法是正确的？（ ）

A.

switch(x) {
    case 1: printf("x is 1"); break;
    else: printf("x is not 1"); break;
}

B.

switch(x) {
    case 1: printf("x is 1"); break;
    default: printf("x is not 1"); break;
}

C.

switch(x) {
    case 1: printf("x is 1");
    else: printf("x is not 1");
}

D.

switch(x) {
    case 1: printf("x is 1"); continue;
    case 2: printf("x is 2"); break;
}

解析：switch 的兜底分支应为 default，不能用 else；continue 不能用于 switch（除非在内层循环中）。
答案：B

12

题目：下列哪个关键字可以用于跳过当前循环中剩余的语句，进入下一次循环？（ ）
A. continue B. exit C. break D. return

解析：continue 结束本轮循环剩余语句，直接进入下一轮；break 是跳出整个循环。
答案：A. continue

13

题目：下列哪个字符串函数可以比较两个字符串的大小？（ ）
A. strlen() B. strcpy() C. strcat() D. strcmp()

解析：strcmp() 按字典序比较两个字符串；strlen() 求长度，strcpy() 复制，strcat() 拼接。
答案：D. strcmp()

14

题目：下列哪个语句可以定义一个指向整型变量的指针变量？（ ）
A. int *x; B. int x; C. int &x; D. int *x();

解析：int *x; 定义整型指针；int *x(); 声明返回整型指针的函数。
答案：A. int *x;

15

题目：下列哪个语句可以输出指针变量 p 所指向的变量的值？（ ）
A. printf("%d", p); B. printf("%d", &p); C. printf("%d", *p); D. printf("%d", **p);

解析：*p 表示解引用，取指针 p 所指向变量的值。
答案：C. printf("%d", *p);

16

题目：不能把字符串 "Hello!" 赋给数组 b 的语句是：（ ）
A. char b[10] = {'H','e','l','l','o','!'}; B. char b[10]; b = "Hello!";
C. char b[10]; strcpy(b, "Hello!"); D. char b[10] = "Hello!";

解析：数组名是地址常量，不能作为左值被整体赋值。
答案：B. char b[10]; b = "Hello!";

17

题目：下列哪个函数参数传递方式可以保护实参的值不被修改？（ ）
A. 数组传递 B. 值传递 C. 引用传递 D. 指针传递

解析：值传递将实参的副本传给形参，形参修改不影响实参。
答案：B. 值传递

18

题目：设有如下定义：

struct sk { int a; float b; } data, *p;

且 p = &data;，则对 data 中的成员 a 的正确引用是：（ ）
A. (*p).data.a B. p.data.a C. (*p).a D. p->data.a

解析：结构体指针访问成员的正确形式为 (*p).a 或 p->a。
答案：C. (*p).a

19

题目：下列哪个描述最准确地表示 C 语言中未初始化的全局 int 变量的默认值？（ ）
A. 0 B. 1 C. 0xFFFF D. 不确定

解析：全局变量和静态变量若未显式初始化，会被编译器自动初始化为 0。
答案：A. 0

20

题目：以下程序输出结果是：（ ）

int x = 1;
int y = 10;
int z = ++x + y--;
printf("%d", z);

A. 10 B. 11 C. 12 D. 13

解析：++x 先自增（x 变为 2，表达式值为 2），y-- 先使用当前值 10（表达式值为 10），然后 y 自减为 9。因此 z = 2 + 10 = 12。
答案：C. 12

21

题目：下面有关 for 循环的正确描述是：（ ）
A. for 循环只能用于循环次数已经确定的情况
B. for 循环是先执行循环体语句，后判断表达式
C. 在 for 循环中，不能用 break 语句跳出循环体
D. for 循环的循环体语句中，可以包含多条语句，但必须用花括号括起来

解析：for 循环体若包含多条语句，必须用大括号 {} 构成复合语句。
答案：D

22

题目：凡是函数中未指定存储类别的局部变量，其隐含的存储类别为：（ ）
A. auto B. static C. extern D. register

解析：函数内未指定存储类别的局部变量默认为 auto（自动变量）。
答案：A. auto

23

题目：下面哪个函数可以交换两个整数的值？（ ）
A. void swap(int a, int b) { int temp = a; a = b; b = temp; }
B. void swap(int *a, int *b) { int temp = a; a = b; b = temp; }
C. void swap(int *a, int *b) { int temp = *a; *a = *b; *b = temp; }
D. int swap(int a, int b) { int temp = a; a = b; b = temp; return temp; }

解析：交换两个整数的值必须传地址，并通过解引用修改原变量的值。
答案：C

24

题目：下列哪个语句可以用于在 C 语言中打开一个文件？（ ）
A. fopen() B. fclose() C. fgetc() D. fgets()

解析：fopen() 用于打开文件，返回文件指针。
答案：A. fopen()

25

题目：若 i 为整型变量，则以下循环执行次数是：（ ）

for (i = 2; i != 0; ) printf("%d", i--);

A. 无限次 B. 0 次 C. 1 次 D. 2 次

解析：i 初始为 2，循环输出 2、1 后 i 变为 0，循环结束。共执行 2 次。
答案：D. 2 次

26

题目：下列哪个描述最准确地表示 C 语言中 while 循环和 do while 循环的循环条件判断时机？（ ）
A. while 和 do while 都在循环执行之前判断
B. while 和 do while 都在循环执行之后判断
C. 时机相同，不影响执行次数
D. while 在循环体执行之前判断，do while 在循环体执行之后判断

解析：while 是先判断后执行（可能 0 次），do while 是先执行后判断（至少 1 次）。
答案：D

27

题目：下列哪个选项是合法的 C 语言标识符？（ ）
A. 2var B. _var2 C. var#2 D. var-2

解析：合法标识符只能由字母、数字、下划线组成，且不能以数字开头。
答案：B. _var2

28

题目：下列哪个关键字不是 C 语言的保留关键字？（ ）
A. static B. continue C. final D. const

解析：final 是 Java 等语言的关键字，不是 C 语言关键字。
答案：C. final

29

题目：下列哪个运算符可以用于在 C 语言中实现逻辑或运算？（ ）
A. || B. && C. ! D. |

解析：|| 是逻辑或；| 是按位或。
答案：A. ||

30

题目：下面哪个语句可以将字符串 s 复制到字符串 t 中？（ ）
A. t = s; B. strcpy(s, t); C. strcpy(t, s); D. strcat(t, s);

解析：strcpy 的参数顺序是目标在前、源在后，即 strcpy(dest, src)。
答案：C. strcpy(t, s);

二、程序阅读选择题（每小题 2 分，共 20 分）

1

题目：

#include <stdio.h>
int main() {
    int i = 0, j = 0;
    while (i < 10) {
        if (i % 2 == 0) {
            j += i;
        }
        i++;
    }
    printf("%d\n", j);
    return 0;
}

A. 20 B. 25 C. 30 D. 45

解析：循环累加 0~9 中的偶数：0 + 2 + 4 + 6 + 8 = 20。
答案：A. 20

2

题目：

#include <stdio.h>
int main() {
    int a = 10, b = 3;
    float c;
    c = a / b;
    printf("%f\n", c);
    return 0;
}

A. 3 B. 3.000000 C. 3.333333 D. 3.666667

解析：10 / 3 为整数除法，结果为 3，再赋给 float 后输出 3.000000。
答案：B. 3.000000

3

题目：

#include <stdio.h>
int main() {
    int a[5] = {1, 3, 2, 4};
    int *p = a;
    printf("%d\n", *p);
    printf("%d\n", *(++p));
    return 0;
}

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

解析：*p 为数组首元素 1；++p 使指针后移一位，指向 a[1] 即 3。
答案：C. 1 3

4

题目：

#define X 5
#define Y X+1
#define Z Y*X/2
int main() {
    int a = Y;
    printf("%d, %d", Z, --a);
    return 0;
}

A. 7, 6 B. 12, 6 C. 12, 5 D. 7, 5

解析：宏为纯文本替换。Z 展开为 X+1*X/2 = 5+1*5/2 = 5+2 = 7；a = Y = X+1 = 6，--a 后为 5。
答案：D. 7, 5

5

题目：

#include <stdio.h>
int main() {
    int i;
    for (i = 0; i < 5; i++) {
        if (i == 3)
            continue;
        printf("%d", i);
    }
    return 0;
}

A. 0124 B. 01234 C. 0134 D. 01324

解析：i == 3 时 continue 跳过本次循环的 printf，因此不输出 3。
答案：A. 0124

6

题目：

#include <stdio.h>
int main() {
    int a[] = {1, 2, 3};
    int *p = a;
    int *q = &a[2];
    printf("%d", q[-1]);
    return 0;
}

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

解析：q[-1] 等价于 *(q - 1)，即取 a[1]，值为 2。
答案：B. 2

7

题目：

#include <stdio.h>
int main() {
    char a[] = "abcde";
    char *p = a;
    *(p + 2) = '\0';
    printf("%s", a);
    return 0;
}

A. abc B. ab C. abe D. cde

解析：将第三个字符（索引 2）改为 '\0' 后，字符串在此截断，输出 ab。
答案：B. ab

8

题目：

#include <stdio.h>
int main() {
    int a[2][2] = {{1,2},{3,4}};
    printf("%d", sizeof(a) / sizeof(a[0]));
    return 0;
}

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

解析：sizeof(a) 是整个二维数组的大小（16 字节），sizeof(a[0]) 是一行的大小（8 字节），相除得行数 2。
答案：B. 2

9

题目：

#include <stdio.h>
struct point { int x; int y; };
int main() {
    struct point p1 = {1, 2};
    struct point p2 = {3, 4};
    struct point *pp = &p1;
    pp = &p2;
    printf("(%d, %d) (%d, %d)", p1.x, p1.y, pp->x, pp->y);
    return 0;
}

A. (1,2) (1,2) B. (3,4) (3,4) C. (1,2) (3,4) D. (3,4) (1,2)

解析：改变指针 pp 的指向不影响结构体变量 p1 的值；pp 最终指向 p2。
答案：C. (1, 2) (3, 4)

10

题目：

#include <stdio.h>
int x = 1;
int main() {
    int x = 2;
    if (x == 2) {
        int x = 3;
    }
    printf("%d", x);
    return 0;
}

A. 1 B. 2 C. 3 D. 报错

解析：if 块内的 x = 3 只在该块作用域内有效，块外访问的是 main 中的局部变量 x = 2。
答案：B. 2

三、编程题（共 50 分）

1（10 分）

题目：根据以下分段函数计算并输出 y，输入为实数 x，输出保留 3 位有效数字。

• 当 x < 1 时，y = x³
• 当 1 ≤ x < 10 时，y = √x − 1
• 当 x ≥ 10 时，y = 3x − 11

解析：读入 x，分三类讨论，用 if ... else if ... else 实现，需包含 <math.h>。

参考代码：

#include <stdio.h>
#include <math.h>

int main(void) {
    double x, y;
    scanf("%lf", &x);

    if (x < 1) {
        y = x * x * x;
    } else if (x < 10) {
        y = sqrt(x) - 1;
    } else {
        y = 3 * x - 11;
    }

    printf("%.3g
", y);   /* %.3g 保留 3 位有效数字 */
    return 0;
}

2（10 分）

题目：编写完整程序，找到并输出 1~100 之间能被 7 整除但不能被 3 整除的所有偶数，计算并输出满足该条件的所有数的累加和。

解析：遍历 1 到 100，同时满足三个条件（被 7 整除、不被 3 整除、偶数）即输出并累加。

参考代码：

#include <stdio.h>

int main(void) {
    int i, sum = 0;

    for (i = 1; i <= 100; i++) {
        if (i % 7 == 0 && i % 3 != 0 && i % 2 == 0) {
            printf("%d ", i);
            sum += i;
        }
    }

    printf("
%d
", sum);
    return 0;
}

3（14 分）

题目：编写完整程序实现对字符串的处理。主函数定义两个字符数组 char stra[20], strb[20];，利用 gets 输入，定义 char strc[40]; 存放连接结果。编写以下函数，不得调用 string.h 中的任何函数：

1. int mystrlen(char pstr[])：返回字符串长度（不含 '\0'）。
2. void mystrreverse(char pstr[])：将字符串反序（例如 "abcd" → "dcba"）。
3. void mystrcat(char pstra[], char pstrb[], char pstrc[])：将两个字符串连接，存放在 pstrc 中。
4. 主函数先输入两个字符串，分别调用 mystrreverse 反序并输出，再调用 mystrcat 连接并输出结果。

⚠️ 注意：gets() 函数因存在缓冲区溢出风险，已在 C11 标准中移除。实际开发中请使用 fgets() 替代。以下代码保留原题要求。

解析：字符串以 '\0' 结尾；反转用双指针交换；拼接先拷贝第一个串再拷贝第二个串。

参考代码：

#include <stdio.h>

int mystrlen(char pstr[]) {
    int len = 0;
    while (pstr[len] != '\0') {
        len++;
    }
    return len;
}

void mystrreverse(char pstr[]) {
    int i = 0;
    int j = mystrlen(pstr) - 1;
    char temp;

    while (i < j) {
        temp = pstr[i];
        pstr[i] = pstr[j];
        pstr[j] = temp;
        i++;
        j--;
    }
}

void mystrcat(char pstra[], char pstrb[], char pstrc[]) {
    int i = 0, j = 0;

    while (pstra[i] != '\0') {
        pstrc[i] = pstra[i];
        i++;
    }
    while (pstrb[j] != '\0') {
        pstrc[i] = pstrb[j];
        i++;
        j++;
    }
    pstrc[i] = '\0';
}

int main(void) {
    char stra[20], strb[20], strc[40];

    gets(stra);
    gets(strb);

    mystrreverse(stra);
    mystrreverse(strb);
    printf("%s
", stra);
    printf("%s
", strb);

    mystrcat(stra, strb, strc);
    printf("%s
", strc);
    return 0;
}

4（18 分）

题目：编写一个完整程序，完成举重比赛 8 名运动员的成绩分析和排名。具体要求：

1. 编写 input 函数，输入运动员的姓名、三次挺举成绩、三次抓举成绩（失败或不合格记 0）。
2. 编写 score 函数，分别取挺举和抓举的最大值作为最终成绩，并计算总成绩。
3. 编写 sort1，按挺举最终成绩从高到低排序，输出前三名（姓名、挺举成绩、排名）。
4. 编写 sort2，按抓举最终成绩从高到低排序，输出前三名（姓名、抓举成绩、排名）。
5. 编写 sort3，按总成绩从高到低排序，输出前三名（姓名、挺举成绩、抓举成绩、总成绩、排名）。
6. 主函数依次调用上述函数。

解析：使用结构体保存信息；排序前复制数组以免影响后续排序；使用冒泡排序。

参考代码：

#include <stdio.h>
#include <string.h>

#define N 8

typedef struct {
    char name[20];
    float caj_atp[3];   /* 挺举三次成绩 */
    float sna_atp[3];   /* 抓举三次成绩 */
    float caj;          /* 挺举最终成绩 */
    float sna;          /* 抓举最终成绩 */
    float total;        /* 总成绩 */
} Weightlifting;

void input(Weightlifting a[], int n) {
    int i, j;
    for (i = 0; i < n; i++) {
        scanf("%19s", a[i].name);
        for (j = 0; j < 3; j++) scanf("%f", &a[i].caj_atp[j]);
        for (j = 0; j < 3; j++) scanf("%f", &a[i].sna_atp[j]);
    }
}

float max3(float x[3]) {
    float m = x[0];
    int i;
    for (i = 1; i < 3; i++) {
        if (x[i] > m) m = x[i];
    }
    return m;
}

void score(Weightlifting a[], int n) {
    int i;
    for (i = 0; i < n; i++) {
        a[i].caj = max3(a[i].caj_atp);
        a[i].sna = max3(a[i].sna_atp);
        a[i].total = a[i].caj + a[i].sna;
    }
}

void copy_array(Weightlifting dest[], Weightlifting src[], int n) {
    int i;
    for (i = 0; i < n; i++) dest[i] = src[i];
}

void sort_by_caj(Weightlifting a[], int n) {
    int i, j;
    Weightlifting t;
    for (i = 0; i < n - 1; i++) {
        for (j = 0; j < n - 1 - i; j++) {
            if (a[j].caj < a[j + 1].caj) {
                t = a[j]; a[j] = a[j + 1]; a[j + 1] = t;
            }
        }
    }
}

void sort_by_sna(Weightlifting a[], int n) {
    int i, j;
    Weightlifting t;
    for (i = 0; i < n - 1; i++) {
        for (j = 0; j < n - 1 - i; j++) {
            if (a[j].sna < a[j + 1].sna) {
                t = a[j]; a[j] = a[j + 1]; a[j + 1] = t;
            }
        }
    }
}

void sort_by_total(Weightlifting a[], int n) {
    int i, j;
    Weightlifting t;
    for (i = 0; i < n - 1; i++) {
        for (j = 0; j < n - 1 - i; j++) {
            if (a[j].total < a[j + 1].total) {
                t = a[j]; a[j] = a[j + 1]; a[j + 1] = t;
            }
        }
    }
}

int main(void) {
    Weightlifting a[N], b[N];
    int i;

    input(a, N);
    score(a, N);

    copy_array(b, a, N);
    sort_by_caj(b, N);
    for (i = 0; i < 3; i++)
        printf("%d %s %.1f
", i + 1, b[i].name, b[i].caj);

    copy_array(b, a, N);
    sort_by_sna(b, N);
    for (i = 0; i < 3; i++)
        printf("%d %s %.1f
", i + 1, b[i].name, b[i].sna);

    copy_array(b, a, N);
    sort_by_total(b, N);
    for (i = 0; i < 3; i++)
        printf("%d %s %.1f %.1f %.1f
", i + 1, b[i].name, b[i].caj, b[i].sna, b[i].total);

    return 0;
}

附加题（30 分）

1（15 分）

题目：编写完整程序，输入任意正整数 n（n < 100），把自然数列 1, 2, 3, … 按螺旋形填入 n × n 方阵，并打印该方阵。例如五阶方阵：

 1  2  3  4  5
16 17 18 19  6
15 24 25 20  7
14 23 22 21  8
13 12 11 10  9

解析：用四个边界 top、bottom、left、right 控制一圈一圈填入，每填完一条边收缩对应边界。

参考代码：

#include <stdio.h>

int main(void) {
    int n, a[100][100];
    int top = 0, bottom, left = 0, right;
    int num = 1;
    int i;

    scanf("%d", &n);
    bottom = n - 1;
    right  = n - 1;

    while (top <= bottom && left <= right) {
        for (i = left; i <= right; i++) a[top][i] = num++;
        top++;

        for (i = top; i <= bottom; i++) a[i][right] = num++;
        right--;

        if (top <= bottom) {
            for (i = right; i >= left; i--) a[bottom][i] = num++;
            bottom--;
        }

        if (left <= right) {
            for (i = bottom; i >= top; i--) a[i][left] = num++;
            left++;
        }
    }

    for (i = 0; i < n; i++) {
        int j;
        for (j = 0; j < n; j++) {
            printf("%4d", a[i][j]);
        }
        printf("
");
    }
    return 0;
}

2（15 分）

题目：有 n 个人围成一圈，顺序排号，从第 s 个人开始从 1 到 m 报数，凡是报到 m 的人退出圈子，下一个人重新从 1 开始报数，直到所有人都退出。编写完整程序，输入 n、s、m，输出出圈序列。要求使用结构体数组实现。

解析：经典的约瑟夫环问题。用结构体数组存编号和是否出圈标记，循环报数，数到 m 的人出圈并输出。

参考代码：

#include <stdio.h>

typedef struct {
    int id;
    int out;    /* 0 表示未出圈，1 表示已出圈 */
} Person;

int main(void) {
    Person p[1000];
    int n, s, m;
    int i, left, cur, cnt;

    scanf("%d%d%d", &n, &s, &m);
    for (i = 0; i < n; i++) {
        p[i].id = i + 1;
        p[i].out = 0;
    }

    left = n;
    cur = s - 1;    /* 转换为 0 基索引 */
    cnt = 0;

    while (left > 0) {
        if (!p[cur].out) {
            cnt++;
            if (cnt == m) {
                printf("%d ", p[cur].id);
                p[cur].out = 1;
                left--;
                cnt = 0;
            }
        }
        cur = (cur + 1) % n;
    }
    printf("
");
    return 0;
}

第二部分：2024 期末试卷（B 卷）逐题解析

一、单项选择题（每小题 1 分，共 30 分）

1

题目：设有整型变量 a、b、c，且 a、b 的值分别为 10 与 20，则执行 c = (a > b) ? a : b; 后 c 的值为：（ ）
A. 0 B. 1 C. 10 D. 20

解析：条件运算符 ?: 中，10 > 20 为假，取 b 的值 20。
答案：D. 20

2

题目：C 语言的预处理命令可以实现：（ ）
A. 宏定义 B. 文件包含 C. 条件编译 D. 以上都是

解析：预处理命令包括宏定义（#define）、文件包含（#include）、条件编译（#if / #ifdef 等）。
答案：D. 以上都是

3

题目：下列四组选项中，均不是 C 语言关键字的选项是：（ ）
A. sum mul sub B. getc char printf C. include scanf case D. while go pow

解析：char、case、while 均为 C 关键字；只有 A 选项中的三个标识符都不是关键字。
答案：A. sum mul sub

4

题目：十进制数 35 转换为二进制数是：（ ）
A. 100011 B. 100111 C. 100110 D. 100101

解析：35 = 32 + 2 + 1 = 2⁵ + 2¹ + 2⁰，二进制为 100011。
答案：A. 100011

5

题目：C 语言中的标识符只能由字母、数字和下划线三种字符组成，且第一个字符：（ ）
A. 可以是字母、数字和下划线中任一种字符
B. 必须是字母或下划线

解析：C 语言标识符首字符只能是字母或下划线，不能以数字开头。
答案：B. 必须是字母或下划线

6

题目：要说明一个类型名 SMP，使得定义语句 SMP ch; 等价于 char *ch;，以下选项中正确的是：（ ）
A. typedef SMP * char; B. typedef * SMP char;
C. typedef char * SMP; D. typedef * char SMP;

解析：typedef 的语法为 typedef 原类型 新类型名;，因此 typedef char * SMP; 正确。
答案：C. typedef char * SMP;

7

题目：已知字母 A 的 ASCII 码为十进制数 65，且 c2 为字符型变量，则执行语句 c2 = 'A' + '6' - '3'; 后，printf("%c", c2) 输出：（ ）
A. D B. 68 C. 无法确定 D. C

解析：'6' - '3' = 54 - 51 = 3，所以 'A' + 3 = 65 + 3 = 68，对应字符 'D'。
答案：A. D

勘误：原 OCR 版本此处答案误标为 D，已修正。

8

题目：以下叙述正确的是：（ ）
A. 转义字符要用双引号括起来
B. 字符常量在内存中占 2 个字节
C. 字符常量需要用单引号括起来
D. 字符常量是不能进行关系运算的

解析：字符常量必须用单引号括起来；转义字符是单个字符，也用单引号；在内存中占 1 字节；字符常量可以进行关系运算（按 ASCII 码值比较）。
答案：C. 字符常量需要用单引号括起来

9

题目：以下叙述中正确的是：（ ）
A. if 语句中必须要有 else
B. if 和 else 子句中可以是任意的合法的 C 语句
C. 不能在 else 子句中再使用 if 语句
D. 改变 if-else 的缩进格式会改变程序的执行流程

解析：if 和 else 后面都可以跟任意一条合法的 C 语句（包括复合语句、嵌套 if 等）；缩进不影响执行流程。
答案：B. if 和 else 子句中可以是任意的合法的 C 语句

10

题目：在 C 语言中，一个函数不写返回值类型，默认的返回类型是：（ ）
A. int B. char C. void D. A、B、C 都不是

解析：按传统 C89/C90 标准及国内考试语境，不写返回值类型默认按 int 处理（C99 起已要求显式声明，但考试中仍按旧标准）。
答案：A. int

11

题目：以下（ ）是正确的浮点数。
A. e3 B. .62 C. 2e4.5 D. 123

解析：.62 是合法浮点数（整数部分省略）；e3 缺少尾数，2e4.5 指数不能为小数，123 是整数。
答案：B. .62

12

题目：以下描述中正确的是：（ ）
A. do-while 语句构成的循环，当 while 后的表达式为零时结束循环
B. do-while 语句构成的循环，当 while 后的表达式为非零时结束循环
C. do-while 语句构成的循环只能用 break 退出
D. do-while 语句构成的循环可以用 continue 退出

解析：do while 在 while 后的表达式为 0（假）时结束循环；continue 不能退出循环，只能跳过本轮剩余语句。
答案：A. 当 while 后的表达式为零时结束循环

13

题目：下列运算符中优先级最高的是：（ ）
A. <= B. = C. ! D. &&

解析：! 是单目逻辑非运算符，优先级高于关系运算符（<=）、赋值运算符（=）和逻辑与（&&）。
答案：C. !

14

题目：设 char c; int a; float x; double y;，则表达式 c * a + y - x 的值的数据类型为：（ ）
A. double B. float C. char D. int

解析：表达式中存在 double 类型，根据 C 语言的类型提升规则，整个表达式的结果会提升为 double。
答案：A. double

15

题目：若要定义一个符号常量，下列正确的是：（ ）
A. #define PI 3.14159 B. #define PI = 3.14159
C. #define PI = 3.14159; D. #define PI 3.14159;

解析：宏定义不能带等号和分号，应为 #define 标识符 替换文本。
答案：A. #define PI 3.14159

16

题目：在标准库函数中，将两个字符串连接起来组成一个字符串时，选用（ ）函数。
A. strlen() B. strcpy() C. strcat() D. strcmp()

解析：strcat() 用于拼接字符串；strcpy() 用于复制。
答案：C. strcat()

17

题目：sizeof(double) 是：（ ）
A. 一个整型表达式 B. 一个双精度型表达式
C. 一个不合法的表达式 D. 一个字符型表达式

解析：sizeof 是编译时运算符，其结果类型为 size_t（无符号整型），因此是一个整型表达式。
答案：A. 一个整型表达式

18

题目：以下哪个选项一定可以将 flag 的第一个 bit 置 0？（ ）
A. flag &= ~2; B. flag |= 2; C. flag *= 2; D. flag >>= 2;

解析：按位与 & 可用于清零。~2 的二进制为 ...11111101，与 flag 相与会将 bit1（从 0 开始计数的第二位）清零。若题目意图是清除 bit1，则 A 正确；若意图是清除最低位（bit0），则应使用 ~1。鉴于选项中只有 A 是按位与清零操作，且其他选项明显错误，选择 A。

答案：A. flag &= ~2;

说明：若题目确指"最低位 bit0"，则正确答案应为 flag &= ~1;，但选项中未提供。

19

题目：下述关于循环体的描述中，（ ）是错误的。
A. 当循环体中遇到 break 时，立即跳出当前循环结构
B. 当循环体中遇到 continue 时，立即跳出当前循环结构
C. 在循环嵌套中，break 只能跳出包含它的最近一层循环
D. 在循环嵌套中，continue 只能跳过包含它的最近一层的本次循环

解析：continue 不是跳出循环，而是跳过本轮循环的剩余语句，直接进入下一轮。
答案：B. 当循环体中遇到 continue 时，立即跳出当前循环结构

20

题目：C 语言中，下列表达式能表示 a 大于 0 且小于 100 的是：（ ）
A. a > 0 & a < 100 B. a > 0 && a < 100
C. 0 < a < 100 D. !(a < 0 || a > 100)

解析：应使用逻辑与 && 连接两个条件；0 < a < 100 在 C 语言中是合法的但语义错误（先算 0 < a 得 0 或 1，再与 100 比较）。
答案：B. a > 0 && a < 100

21

题目：printf 函数中用到格式符 %5s，其中数字 5 表示输出的字符串占用 5 列，如果字符串长度大于 5，则输出按方式：（ ）
A. 从左起输出该字符串，右补空格
B. 按原字符长从左到右全部输出
C. 右对齐输出该字串，左补空格
D. 输出错误信息

解析：%5s 指定最小字段宽度为 5，若字符串长度超过 5，会按原长度完整输出（不会截断）。
答案：B. 按原字符长从左到右全部输出

22

题目：设有：int *p, m = 6, n = 0;，以下正确的程序段是：（ ）
A. p = &n; scanf("%d", &p); B. p = &n; scanf("%d", *p);
C. scanf("%d", &n); *p = n; D. p = &n; *p = m;

解析：D 选项中 p 指向 n 后，*p = m 等价于 n = m，完全正确。A 中 &p 是二级指针；B 中 *p 是值，但 scanf 需要地址；C 中 p 未初始化，野指针。
答案：D. p = &n; *p = m;

23

题目：以下能对二维数组 a 进行正确初始化的语句是：（ ）
A. int a[2][] = {{0,1,2},{3,4,5}}; B. int a[][3] = {{0,1,2},{3,4,5}};
C. int a[2][4] = {{0,1,2},{3,4},{5}}; D. int a[][3] = {{0,1,2},{},{3,4,5}};

解析：二维数组初始化时只能省略第一维（行数），不能省略第二维（列数）；初始化列表中不能出现空的大括号 {}。
答案：B. int a[][3] = {{0,1,2},{3,4,5}};

24

题目：数组定义为 int a[4];，表达错误的是：（ ）
A. &a[0] B. a[0] C. a D. a++

解析：数组名 a 是地址常量（不可修改的指针），不能进行自增运算。
答案：D. a++

25

题目：若执行 fopen 打开文件失败，则返回：（ ）
A. 地址值 B. 0 C. 1 D. EOF

解析：fopen() 失败时返回 NULL（在 C 中 NULL 通常定义为 0 或 (void*)0）。
答案：B. 0（即 NULL）

26

题目：关于全局变量以下描述错误的是：（ ）
A. 全局变量的作用域是从变量定义处到程序文件末尾
B. 全局变量的定义必须在所有函数之外
C. 全局变量说明不能扩展全局变量的作用域
D. 全局变量说明不能对全局变量赋初始值

解析：extern 声明可以扩展全局变量的作用域（使其在声明处可见），因此"不能扩展"是错误的描述。
答案：C. 全局变量说明不能扩展全局变量的作用域

27

题目：下列叙述错误的是：（ ）
A. 函数体内不能再定义另一个函数
B. 定义函数时函数名和函数类型必须指明
C. 定义函数时必须有函数体
D. 定义函数时必须有形式参数

解析：C 语言函数定义时可以没有形参（如 void func(void) 或 void func()），因此"必须有形式参数"是错误的。
答案：D. 定义函数时必须有形式参数

28

题目：若用数组名作为函数的参数，则传递给对应形参的是：（ ）
A. 数组的首地址 B. 数组的长度 C. 数组的第一个元素的值 D. 数组中全部元素的值

解析：数组名在大多数表达式中会退化为指向首元素的指针，因此传递的是首地址。
答案：A. 数组的首地址

29

题目：C 语言结构体类型变量在程序执行期间：（ ）
A. 所有成员一直驻留在内存中 B. 只有一个成员驻留在内存中
C. 部分成员驻留在内存中 D. 没有成员驻留在内存中

解析：结构体变量分配内存后，其所有成员同时驻留在内存中（各成员占用自己的内存空间）。
答案：A. 所有成员一直驻留在内存中

30

题目：有以下定义 struct data { int i; char c; double d; } x;，以下叙述中错误的是：（ ）
A. x 的内存地址与 x.i 的内存地址相同
B. struct data 是一个类型名
C. 初始化时，可以对 x 的所有成员同时赋初值
D. 成员 i、c、d 占用的是同一个存储空间

解析：结构体各成员各自占用独立的存储空间（与联合体 union 不同），因此 D 错误。
答案：D. 成员 i、c、d 占用的是同一个存储空间

二、程序阅读选择题（每小题 2 分，共 20 分）

1

题目：

#include <stdio.h>
int x = 5, y = 7;
void swap();
int main() {
    int x = 3, y = 8;
    swap();
    printf("%d,%d
", x, y);
    return 0;
}
void swap() {
    int z = x;
    x = y;
    y = z;
}

A. 3,8 B. 8,3 C. 5,7 D. 7,5

解析：swap() 中操作的是全局变量 x 和 y，但 main 中打印的是局部变量 x=3, y=8，因此输出不受影响。
答案：A. 3,8

2

题目：

#include <stdio.h>
#include <string.h>
int main() {
    static char s[10] = "egdh9�and";
    printf("%d
", strlen(s));
    return 0;
}

A. 6 B. 5 C. 11 D. 10

解析：strlen 遇到 '�' 即结束计数，因此只统计 egdh9 共 5 个字符。
答案：B. 5

3

题目：

#include <stdio.h>
int main() {
    char a[10] = {'1','2','3','4','5','6','7','8','9','�'}, *p;
    int i = 8;
    p = a + i;
    printf("%s
", p - 3);
    return 0;
}

A. 6 B. 6789 C. 6（可能是乱码） D. 789

解析：p 指向字符 '9'（索引 8），p - 3 指向索引 5 的字符 '6'，从 '6' 到结尾输出 6789。
答案：B. 6789

4

题目：

#include <stdio.h>
int main() {
    char c = '1';
    switch(c) {
        case '1': printf("1");
        case '2': printf("2");
        case '3': printf("3");
        default: printf("error");
    }
    return 0;
}

A. 1 B. 2 C. 3 D. 123error

解析：switch 中没有 break，匹配 case '1' 后会依次贯穿执行后续所有 case。
答案：D. 123error

5

题目：

#include <stdio.h>
int main() {
    int a = 2, b = 0;
    if (!a)
        b++;
    else if (a == 1)
        b += 2;
    else
        b += 3;
    printf("%d
", b);
    return 0;
}

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

解析：a = 2，!a 为假，a == 1 为假，执行 else b += 3，b 由 0 变为 3。
答案：C. 3

6

题目：

#include <stdio.h>
int main() {
    int a = 16, b = 21, m = 0;
    switch (a % 3) {
        case 0: m++; break;
        case 1: m++;
            switch (b % 2) {
                default: m++;
                case 0: m++; break;
            }
    }
    printf("%d
", m);
    return 0;
}

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

解析：a % 3 = 1，进入 case 1，m 变为 1；内层 switch(b % 2) 中 b % 2 = 1，匹配 default，m 变为 2，然后贯穿到 case 0，m 变为 3，遇到 break 跳出内层。外层无 break，但已到最后。最终 m = 3。
答案：C. 3

7

题目：

#include <stdio.h>
int main() {
    int m, n;
    scanf("%d%d", &m, &n);
    while (m != n) {
        while (m > n) m = m - n;
        while (n > m) n = n - m;
    }
    printf("m=%d
", m);
    return 0;
}

输入 65 14，输出：
A. m=3 B. m=2 C. m=1 D. m=0

解析：辗转相减法求最大公约数。65 和 14 的最大公约数为 1。
答案：C. m=1

8

题目：

#include <stdio.h>
int main() {
    int a = 2, b = 2, c = 2;
    printf("%d
", (a / b) & c);
    return 0;
}

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

解析：a / b = 2 / 2 = 1，1 & 2 的二进制为 01 & 10 = 00，结果为 0。
答案：A. 0

9

题目：

#include <stdio.h>
struct stu { int x; int *y; };
int main() {
    int dt[4] = {10, 20, 30, 40};
    struct stu a[4] = {
        {50, &dt[0]},
        {60, &dt[1]},
        {70, &dt[2]},
        {88, &dt[3]}
    };
    struct stu *p = a;
    printf("%d,", ++p->x);
    printf("%d,", (++p)->x);
    printf("%d", ++(*p->y));
    return 0;
}

A. 10,20,20 B. 50,60,21 C. 31,60,21 D. 60,70,31

解析：

1. ++p->x：运算符优先级 -> 高于 ++，等价于 ++(p->x)。p 指向 a[0]，p->x = 50，自增后输出 51。
2. (++p)->x：p 先自增指向 a[1]，输出 a[1].x 即 60。
3. ++(*p->y)：p 指向 a[1]，p->y = &dt[1]，*p->y = dt[1] = 20，自增后输出 21。

正确输出为 51,60,21。原卷选项存在笔误，无完全匹配项，但按计算逻辑正确答案应为 51, 60, 21。

答案：正确输出为 51,60,21（原卷选项 C 为笔误）

10

题目：

#include <stdio.h>
int main() {
    int a = 0, b = 0;
    for (a = 1, b = 1; a <= 100; a++) {
        if (b >= 20) break;
        if (b % 3 == 1) {
            b = b + 3;
            continue;
        }
    }
    printf("%d
", a);
    return 0;
}

A. 0 B. 1 C. 6 D. 8

解析：

• 初始 a=1, b=1。
• 每轮 b % 3 == 1 均成立（b 依次为 1, 4, 7, 10, 13, 16, 19, 22...），b 每次加 3。
• 当 b = 22 时（第 8 轮，此时 a 已自增到 8），b >= 20 成立，break。
• 此时 a = 8，输出 8。

答案：D. 8

三、编程题（共 50 分）

1（8 分）

题目：编写一个完整的 C 语言程序，输入一个整数矩阵，找出每一列的最大值并输出。
输入：第一行包含两个整数，分别为矩阵的行数 m 和列数 n（m ≤ 50，n ≤ 20），两数之间以一个空格分隔。随后 m 行，每行 n 个整数（范围 0~100）。
输出：一行，按列顺序输出每列的最大值，中间用空格分隔。

输入样例：

2 4
1 6 3 8
5 2 7 4

输出样例：

5 6 7 8

解析：按列扫描，每列维护一个最大值。

参考代码：

#include <stdio.h>

int main(void) {
    int a[50][20];
    int m, n, i, j;

    scanf("%d%d", &m, &n);
    for (i = 0; i < m; i++) {
        for (j = 0; j < n; j++) {
            scanf("%d", &a[i][j]);
        }
    }

    for (j = 0; j < n; j++) {
        int mx = a[0][j];
        for (i = 1; i < m; i++) {
            if (a[i][j] > mx) mx = a[i][j];
        }
        printf("%d", mx);
        if (j != n - 1) printf(" ");
    }
    printf("
");
    return 0;
}

2（10 分）

题目：编写一个完整的 C 语言程序，用于查找子字符串在主字符串中首次出现的位置（不使用库函数）。程序接收两个不含空格的字符串：主字符串 mainStr（长度 ≤ 100）和子串 subStr（长度 ≤ 50）。输出子串首次出现的起始索引（从 0 开始），若不存在则输出 -1。

输入样例：

Shenzhen
en

输出样例：

2

解析：枚举主串每个可能的起始位置，再逐字符比较。

参考代码：

#include <stdio.h>

int mystrlen(char s[]) {
    int len = 0;
    while (s[len] != '\0') len++;
    return len;
}

int main(void) {
    char mainStr[101], subStr[51];
    int i, j;
    int len1, len2;
    int pos = -1;

    scanf("%100s", mainStr);
    scanf("%50s", subStr);

    len1 = mystrlen(mainStr);
    len2 = mystrlen(subStr);

    for (i = 0; i <= len1 - len2; i++) {
        for (j = 0; j < len2; j++) {
            if (mainStr[i + j] != subStr[j]) break;
        }
        if (j == len2) {
            pos = i;
            break;
        }
    }

    printf("%d
", pos);
    return 0;
}

3（14 分）

题目：判断回文质数。大于 1 的自然数中，除了 1 和它本身以外不再有其他因数的数叫做质数；若一个自然数的各位数字反向排列所得的数与原数相等，则称为回文数。如果一个数既是质数又是回文数，称为回文质数。如 131、353。
请编写函数判断一个数是否是质数；编写函数判断一个数是否是回文数（提示：循环取余反转整数）。如果 x 是回文质数输出 yes，否则输出 no。
输入：一个正整数 x（1 < x < 100000000）。

输入样例：131 输出样例：yes

解析：先写 isPrime() 试除到 sqrt(n)，再写 isPalindrome() 反转整数判断。

参考代码：

#include <stdio.h>

int isPrime(int x) {
    int i;
    if (x < 2) return 0;
    for (i = 2; i * i <= x; i++) {
        if (x % i == 0) return 0;
    }
    return 1;
}

int isPalindrome(int x) {
    int t = x, rev = 0;
    while (t > 0) {
        rev = rev * 10 + t % 10;
        t /= 10;
    }
    return rev == x;
}

int main(void) {
    int x;
    scanf("%d", &x);
    if (isPrime(x) && isPalindrome(x))
        printf("yes
");
    else
        printf("no
");
    return 0;
}

4（18 分）

题目：编写一个职工信息管理系统。功能：

1. 编写 inputEmployeeInfo 函数录入职工信息：职工号（≤20 字符）、姓名（≤50）、职位（≤50）、基本工资（浮点）、奖金（浮点）、考勤分（整型）。
2. 编写 displayEmployeeInfo 函数显示所有职工信息（包括总薪资 = 基本工资 + 奖金）。
3. 编写 sortByTotalSalary 函数按总薪资从高到低排序。
4. 编写 sortByAttendanceScore 函数按考勤分从高到低排序。

主函数流程：录入 → 显示原始信息 → 按总薪资排序并显示 → 按考勤分排序并显示。

注意：以下代码假设输入数据不含空格，以便用 scanf 连续读取字符串。若实际输入含空格，应改用 fgets 逐行读取。

解析：结构体保存信息，排序使用冒泡排序。

参考代码：

#include <stdio.h>

#define N 5

typedef struct {
    char employeeID[21];
    char name[51];
    char position[51];
    float baseSalary;
    float bonus;
    int attendanceScore;
} Employee;

void inputEmployeeInfo(Employee e[], int n) {
    int i;
    for (i = 0; i < n; i++) {
        scanf("%20s%50s%50s%f%f%d",
              e[i].employeeID,
              e[i].name,
              e[i].position,
              &e[i].baseSalary,
              &e[i].bonus,
              &e[i].attendanceScore);
    }
}

void displayEmployeeInfo(Employee e[], int n) {
    int i;
    for (i = 0; i < n; i++) {
        printf("%s %s %s %.2f %.2f %d %.2f
",
               e[i].employeeID,
               e[i].name,
               e[i].position,
               e[i].baseSalary,
               e[i].bonus,
               e[i].attendanceScore,
               e[i].baseSalary + e[i].bonus);
    }
}

void sortByTotalSalary(Employee e[], int n) {
    int i, j;
    Employee t;
    for (i = 0; i < n - 1; i++) {
        for (j = 0; j < n - 1 - i; j++) {
            float total_j = e[j].baseSalary + e[j].bonus;
            float total_j1 = e[j + 1].baseSalary + e[j + 1].bonus;
            if (total_j < total_j1) {
                t = e[j]; e[j] = e[j + 1]; e[j + 1] = t;
            }
        }
    }
}

void sortByAttendanceScore(Employee e[], int n) {
    int i, j;
    Employee t;
    for (i = 0; i < n - 1; i++) {
        for (j = 0; j < n - 1 - i; j++) {
            if (e[j].attendanceScore < e[j + 1].attendanceScore) {
                t = e[j]; e[j] = e[j + 1]; e[j + 1] = t;
            }
        }
    }
}

int main(void) {
    Employee e[N];
    inputEmployeeInfo(e, N);
    displayEmployeeInfo(e, N);
    sortByTotalSalary(e, N);
    displayEmployeeInfo(e, N);
    sortByAttendanceScore(e, N);
    displayEmployeeInfo(e, N);
    return 0;
}

第三部分：两套模拟卷

模拟卷一（贴近 2023 风格）

一、单项选择题（每题 1 分，共 30 分）

二、程序阅读选择题（每题 2 分，共 20 分）

三、编程题（共 50 分）

1

输入一个实数 x，按如下分段函数求值并输出：

• x < 0 时，y = x*x + 1
• 0 <= x < 5 时，y = x + 2
• x >= 5 时，y = 2*x - 3

要点：三分支 if-else if-else。

2

输出 1 到 200 之间所有能被 5 整除但不能被 2 整除的数，并输出它们的和。

要点：循环 + 条件筛选（i % 5 == 0 && i % 2 != 0）+ 累加。

3

不调用 string.h 中字符串处理函数，编写：

• mystrlen
• mystrcpy
• mystrcmp

主函数输入两个字符串，输出长度、复制结果、比较结果。

要点：遍历到 '�' 实现各功能；mystrcmp 按字典序比较，相等返回 0。

4

输入 6 名学生的姓名、3 门课成绩，计算平均分，并按平均分从高到低输出前三名。

要点：结构体存储学生信息；冒泡排序按平均分降序；输出前三名。

附加题（每题 15 分）

1

输入 n，输出 n × n 主对角线和副对角线元素之和。

要点：主对角线 a[i][i]，副对角线 a[i][n-1-i]，注意 n 为奇数时中心元素只加一次。

2

n 个人围成一圈，从第 1 个人开始报数，报到 m 的人出圈，输出出圈顺序。

要点：约瑟夫环；数组标记是否出圈；循环报数计数。

模拟卷二（贴近 2024 风格）

一、单项选择题（每题 1 分，共 30 分）

二、程序阅读选择题（每题 2 分，共 20 分）

三、编程题（共 50 分）

1

输入一个 m × n 矩阵，输出每行最小值。

要点：双重循环，按行求最小值。

2

输入两个不含空格字符串，输出第二个字符串在第一个字符串中最后一次出现的位置，不存在输出 -1。

要点：双层循环，从后往前查找首次匹配（即从主串末尾向前遍历）。

3

输入一个正整数，判断其是否同时为回文数和完全平方数。

要点：分别判断回文（反转比较）与完全平方数（sqrt 后判断是否为整数）。

4

编写一个图书信息管理程序：录入书号、书名、价格、库存；按价格排序输出，再按库存排序输出。

要点：结构体数组 + 两次冒泡排序 + 输出。

完