考研复试C语言基础

前言

复试考C语言的时候通过院校公布的考试大纲用deepseek生成下面的题目，并且对不理解的知识点进行了深入学习，现将记录如下，若有错误还希望各位大佬能够给予批评指正。

程序设计和 C 语言、算法

计算机语言的发展阶段顺序是（A）

A. 机器语言 → 汇编语言 → 高级语言        B. 高级语言 → 汇编语言 → 机器语言

C. 汇编语言 → 机器语言 → 高级语言        D. 以上都不对         

以下哪项是 C 语言的特点？（B）

A. 面向对象             B. 可移植性             C. 动态类型             D. 解释执行           

面向过程以“步骤”为核心，将问题分解成一系列的函数，顺序执行。“怎么做”

面向对象以“对象”为核心，将问题抽象为具有属性和行为的对象。“谁来做”

动态类型：程序运行时进行类型检查。

静态类型：编译期或解释期进行类型检查。（变量使用前必须声明其数据类型）

解释型语言：程序运行时，解释器会逐行读取源代码将其转换为机器代码并立即执行。动态不会生成独立的可执行文件。

编译型语言：程序运行前，编译器会将整个源代码一次性编译成机器代码，并生成一个可执行文件。静态

可移植性：很少修改或不经修改就可以在其他系统上运行。

C 语言程序的基本结构中必须包含（B）

A. 预处理指令       B. 主函数 main()              C. 类定义                    D. 以上都是          

运行 C 程序的正确步骤是（A）

A. 编写 → 编译 → 链接 → 执行                  B. 编写 → 执行 → 编译 → 链接               

C. 编译 → 链接 → 编写 → 执                     D. 执行 → 编写 → 链接 → 编译            

算法的特性不包括（C）

A. 有穷性                B. 确定性                C. 随机性                D. 可行性              

C 语言最初由 丹尼斯·里奇（Dennis Ritchie） 在 1972 年开发。

预处理指令 #include <stdio.h> 的作用是 包含标准输入输出库头文件。

算法的五个特性是 有穷性、确定性、可行性、输入、输出。

这个我当时想到随机数的生成是否违反算法的确定性。

简述 C 语言程序的结构。

语言程序由预处理指令（如 #include）、主函数 main()、函数定义和语句组成。主函数是程序执行的入口，函数用于模块化代码。

请写出运行 C 程序的具体步骤。

答案：编写源代码 → 编译生成目标文件（.obj）→ 链接生成可执行文件（.exe）→ 执行程序。

什么是算法？列举算法的特性。

答案：算法是解决问题的明确步骤描述。特性包括：有穷性（步骤有限）、确定性（无歧义）、可行性（可执行）、有输入（0 或多个输入）、有输出（至少一个输出）。

C 语言与汇编语言的主要区别是什么？

答案：C 语言是高级语言，可移植性强，代码更易读写；汇编语言是低级语言，直接操作硬件，执行效率高但可读性差。

四、判断题（每题 2 分，共 10 分）

C 语言程序可以没有 main() 函数。（ ×）   

算法的有穷性指算法必须在有限时间内结束。（√）

printf("Hello"); 是 C 程序中的一条预处理指令。（×）  

编译是将源代码直接转换为可执行文件的过程。（×）        （需先编译后链接）

C 语言支持面向对象编程。（×）          （C 语言是结构化语言）

最简单的 C 程序设计

以下哪个是合法的整型常量？（B）

A. 12.3                                  B. 0x1A                             C. '7'               D. "100"          

转义字符 \n 的作用是（B）

A. 退格  '\b'                  B. 换行                    C. 回车 '\r'                   D. 响铃 '\a'                              

以下变量名合法的是（C）

A. 3var                     B. float                     C. _score                  D. a-b           

符号常量 #define MAX 100 与常变量 const int MAX = 100; 的主要区别是（A）

A. 前者在编译时替换，后者占用内存            B. 后者可以修改         C. 前者支持类型检查             D. 无区别              

 int 类型变量在32位系统中占用的存储空间是（C）

A. 1字节                 B. 2字节                  C. 4字节                 D. 8字节                

表达式 (double)(5 / 2) 的结果是（B）

A. 2                B. 2.0             C. 2.5             D. 3.0            

以下运算符优先级最高的是（C）

A. +                B. *                C. ()                D. =         

C语言运算符，运算符优先级（超详细运算符详解）_c语言运算符优先级-CSDN博客

主要是运算>关系>逻辑,还要注意运算符的结合性，区分指针数组和数组指针。

以下代码的输出是（A）             printf("%d", 10 + 3 * 2); 

A. 16              B. 26              C. 32              D. 13            

使用 scanf 输入一个字符时，正确的格式字符是（B）

A. %d            B. %c             C. %s            D. %f            

printf("%5.2f", 3.14159); 的输出结果是（B）

A. 3.14                      B. 3.14                      C. 3.14159               D. 3.142                   

字符串 "Hello\nC" 中包含 8 个字符（含结束符）。

表达式 (int)3.8 + 2.5 的结果是 5.5（类型为 double）。

printf 函数中，输出十六进制整数的格式字符是 %x。八进制%o，十进制%d。

赋值语句 a = (b > 0) ? b : 0; 的功能是 将b的值赋给a（若b>0），否则赋0。

若 int a = 5;，则执行 a += a -= 2; 后，a 的值是 6。

以下代码的输出是什么？

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

答案： 4（计算：10/3=3，10%3=1，总和为4）

以下代码有何错误？请修正。

int x;                       scanf("请输入x：%d", x);       

答案： 错误：缺少 & 和多余提示文本。修正为 scanf("%d", &x);

分析以下代码的输出：

printf("%d", 5 + 'A' - 2);          

答案： 68（'A'的ASCII码为65，计算：5 + 65 - 2 = 68）

以下代码的功能是什么？

char ch = getchar();                     putchar(ch + 1); 

答案： 输入一个字符，输出其ASCII码值加1后的字符（如输入A，输出B）。

编写程序，输入两个整数，输出它们的和、差、积、商（整数除法）。

#include <stdio.h> int main() { int a, b; scanf("%d%d", &a, &b); printf("和：%d\n差：%d\n积：%d\n商：%d\n", a + b, a - b, a * b, a / b); return 0; }     

编写程序，输入一个浮点数，输出其四舍五入保留两位小数的结果。

#include <stdio.h> int main() { float num; scanf("%f", &num); printf("%.2f", num); return 0; } 

编写程序，输入一个字符，将其转换为大写字母后输出（若本身是大写则不变）。

#include <stdio.h> int main() { char ch; scanf("%c", &ch); if (ch >= 'a' && ch <= 'z') ch -= 32; printf("%c", ch); return 0; } 

编写程序，输入三个整数，找出最大值并输出。

#include <stdio.h> int main() { int a, b, c, max; scanf("%d%d%d", &a, &b, &c); max = a; if (b > max) max = b; if (c > max) max = c; printf("最大值：%d", max); return 0; } 

选择结构程序设计

以下关于if语句的描述，错误的是（C）

A. if语句的条件表达式必须用括号包裹                     B. if语句可以没有else分支

C. if语句的条件表达式结果可以是任意类型             D. if语句可以嵌套使用              

关系运算符 >= 和 == 的优先级顺序是（A）

A. >= 高于 ==                    B. == 高于 >=            C. 两者优先级相同               D. 无法比较    

赋值表达式+=、-=、*=是一样的。        

以下逻辑运算符优先级最高的是（C）

A. &&                       B. ||                C. !                 D. 优先级相同                              

条件表达式 a > b ? a : b 的功能是（B）

A. 返回a和b的和                                 B. 返回a和b的较大值             

C. 返回a和b的较小值                         D. 判断a是否等于b                  

以下代码的输出是（B）

int x = 5; if (x = 0) printf("A"); else printf("B"); 

A. A               B. B                C. 编译错误            D. 无输出               

switch语句的case标签中，不能是以下哪种类型？（C）

A. 整型常量            B. 字符常量            C. 浮点型常量                   D. 宏定义的常量             

允许（整型、字符、枚举、宏定义）常量。

不允许浮点数、字符串/数组，结构体/共用体，非整型指针，变量或非常量表达式。

以下代码的输出是（B）

int a = 3, b = 5; if (a > 2 && b < 4) printf("A"); else printf("B"); 

A. A               B. B               

以下关于switch语句的描述，正确的是（D）

A. default分支必须放在最后                            B. case分支必须用break结束

C. switch表达式可以是浮点类型                     D. case分支的值必须唯一         

以下代码的输出是（C）

int x = 2; switch (x) { case 1: printf("A"); case 2: printf("B"); case 3: printf("C"); default: printf("D"); } 

A. B               B. BC            C. BCD                     D. D              

以下代码的功能是（B）

int score = 85; if (score >= 90) printf("A"); else if (score >= 80) printf("B"); else printf("C"); 

A. 判断成绩是否及格         B. 根据成绩输出等级      C. 计算总分                  D. 输出固定值             

关系表达式 5 != 3 的结果是 1（真）。

逻辑表达式 !(3 > 5) 的结果是 1（真）。

条件表达式的一般形式是 条件 ? 表达式1 : 表达式2。

switch语句中，若所有case都不匹配，则执行 default 分支。

若 int a = 10;，则 if (a % 2 == 0) 的条件结果为 真。

以下代码的输出是 B：

int x = 15; if (x > 20) printf("A"); else if (x > 10) printf("B"); else printf("C"); 

表达式 (5 > 3) && (2 < 4) 的结果是 1（真）。

以下代码的输出是什么？

int a = 7, b = 3; if (a > 5) { if (b < 5) printf("A"); else printf("B"); } else printf("C");     

答案：A

以下代码的输出是什么？

int x = 4; switch (x) { case 1: printf("A"); break; case 4: printf("B"); case 5: printf("C"); break; default: printf("D"); }      

 答案：BC

以下代码是否存在错误？若有，请修正。

int num = 2.5;                   if (num = 2) printf("Yes"); 

答案：错误：赋值运算符=误用为==；num类型不匹配。修正：int num = 2;           if (num == 2) printf("Yes"); 

以下代码的功能是什么？

int a = 10, b = 20;             int max = (a > b) ? a : b;            

答案：求a和b中的较大值并赋值给max

编写程序，输入一个整数，判断其是否为偶数。

#include <stdio.h> int main() { int num; scanf("%d", &num); if (num % 2 == 0) printf("偶数"); else printf("奇数"); return 0; } 

编写程序，输入一个字符，判断它是大写字母、小写字母还是数字。

#include <stdio.h> int main() { char ch; scanf("%c", &ch); if (ch >= 'A' && ch <= 'Z') printf("大写字母"); else if (ch >= 'a' && ch <= 'z') printf("小写字母"); else if (ch >= '0' && ch <= '9') printf("数字"); else printf("其他字符"); return 0; } 

使用switch语句编写程序，根据输入的月份（1-12），输出该月份的天数（假设2月有28天）。

#include <stdio.h> int main() { int month; scanf("%d", &month); switch (month) { case 1: case 3: case 5: case 7: case 8: case 10: case 12: printf("31天"); break; case 4: case 6: case 9: case 11: printf("30天"); break; case 2: printf("28天"); break; default: printf("输入错误"); } return 0; } 

不能case 1,3,5:，一个case对应一个值 

编写程序，输入三个整数，按从小到大的顺序输出。

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

循环结构程序设计

while循环的特点是（B）

A. 先执行循环体，再判断条件              B. 先判断条件，再执行循环体

C. 至少执行一次循环体                         D. 无条件执行循环体                 

以下代码的执行结果是（B）

int i = 5; 

while (i--) printf("%d ", i); 

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

do while循环的结束条件是（C）

A. 条件为真时继续执行                         B. 条件为假时继续执行

C. 无论条件如何，至少执行一次        D. 条件为真时结束循环            

以下代码的输出是（A）

for (int i = 0; i < 3; i++) { 

    if (i == 1) break; 

    printf("%d ", i); 

} 

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

以下关于for循环的描述，错误的是（C）

A. for(;;) 是死循环            B. 循环变量可在循环体内修改

C. 初始化部分只能定义循环变量        D. 循环体可以为空                     

以下代码的输出是（B）

int i = 0; 

do { 

    printf("%d ", i); 

    i++; 

} while (i <= 2); 

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

以下代码的输出是（A）

for (int i = 1; i <= 3; i++) { 

    if (i % 2 == 0) continue; 

    printf("%d ", i); 

} 

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

以下代码中，break的作用是（A）

while (1) { 

    if (x == 0) break; 

    x--; 

} 

A. 结束当前循环       B. 跳过本次循环剩余语句       C. 结束整个程序      D. 无作用                          

以下代码的功能是（B）

for (int i = 0; i < 5; i += 2) printf("%d ", i); 

A. 输出 0 1 2 3 4               B. 输出 0 2 4                      C. 输出 1 3 5                     D. 死循环    

以下代码的输出是（A）

int x = 3; 

do { 

    x--; 

} while (x > 0); 

printf("%d", x); 

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

while循环的一般形式是：while (条件) { 循环体 }。

do while循环的结束条件是：循环体执行后，条件为 假。

for循环的三个表达式分别是：初始化、条件判断、更新循环变量。

以下代码的输出是：1 3 5

for (int i = 1; i <= 5; i += 2) printf("%d ", i); 

break语句的作用是：终止当前循环或switch语句。

以下代码的输出是：0 1 2

int i = 0; while (i < 3) { printf("%d ", i); i++; } 

continue语句的作用是：跳过本次循环剩余代码，进入下一次循环。

以下代码的输出是什么？

int i = 1; while (i <= 4) { if (i == 3) break; printf("%d ", i); i++; }        

答案：1 2

以下代码的输出是什么？

int x = 5; do { x -= 2; printf("%d ", x); } while (x > 0); 

答案：3 1 -1

以下代码是否存在错误？若有，请修正。

for (int i = 0; i < 5; i++); 

    printf("%d ", i); 

答案：错误：for循环后多加分号，导致循环体为空。修正：

for (int i = 0; i < 5; i++) { 

    printf("%d ", i); 

} 

以下代码的功能是什么？

int sum = 0, n = 10; for (int i = 1; i <= n; i++) { sum += i; } printf("%d", sum); 

答案：计算1到10的整数和，结果为55。

编写程序，使用while循环计算1到100的偶数和。

#include <stdio.h> int main() { int i = 1, sum = 0; while (i <= 100) { if (i % 2 == 0) sum += i; i++; } printf("偶数和：%d", sum); return 0; } 

使用do while循环编写程序，输入一个正整数，逆序输出其各位数字。

#include <stdio.h> int main() { int num, digit; scanf("%d", &num); do { digit = num % 10; printf("%d ", digit); num /= 10; } while (num > 0); return 0; } 

编写程序，使用for循环输出所有3位水仙花数（各位数字立方和等于该数本身）。

#include <stdio.h> int main() { for (int i = 100; i <= 999; i++) { int a = i / 100, b = (i / 10) % 10, c = i % 10; if (a*a*a + b*b*b + c*c*c == i) printf("%d ", i); } return 0; } 

编写程序，使用嵌套循环输出如下图形：

* 

** 

*** 

**** 

#include <stdio.h> int main() { for (int i = 1; i <= 4; i++) { for (int j = 1; j <= i; j++) { printf("*"); } printf("\n"); } return 0; } 

利用数组处理批量数据

以下一维数组定义正确的是（C）

A. int a[];                  B. int a[5] = {1,2,3,4,5,6};             C. int a[3] = {0};                 D. int a(5);              

二维数组 int b[2][3]; 的元素个数是（D）

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

以下字符数组初始化正确的是（B）

A. char str[5] = "Hello";  B. char str[] = {'H','e','l','l','o'};

C. char str[5] = {'H','e','l','l','o','\0'};    D. char str = "Hello";

字符串的结束标志是（B）

A. \n               B. \0               C. \t    D.                  

以下代码的输出是（A）

int a[3] = {1, 2};                printf("%d", a[2]); 

A. 0                B. 1                C. 2                D. 随机值       

显示初始化元素个数少于数组长度，剩余未显示初始化的元素会被自动补0。        

二维数组 int arr[2][3] = {{1,2}, {3}}; 中，arr[1][2] 的值是（A）

A. 0                B. 3                C. 1                D. 随机值              

以下代码的输出是（A）

char str[] = "abc";                       printf("%d", strlen(str)); 

A. 3                B. 4                C. 编译错误            D. 随机值              

以下代码的功能是（A）

char s[10];  scanf("%s", s); 

A. 输入一个字符串，最多包含9个字符                   B. 输入一个字符串，最多包含10个字符

C. 输入一个整数              D. 输入一个字符             

以下代码的输出是（A）

int a[5] = {10, 20, 30};      printf("%d", a[3]); 

A. 0                B. 10              C. 30              D. 随机值              

以下二维数组定义中，错误的是（B）

A. int a[][3] = {{1,2}, {3,4}};                  B. int a[2][] = {{1,2}, {3,4}}; 

C. int a[2][3] = {0};                               D. int a[][3] = {1,2,3,4};

二维数组的列数必须显示声明。

一维数组 int arr[5]; 的下标范围是 0到4。

二维数组 int a[3][4]; 共有 3 行，4 列。

初始化字符数组为字符串 "Hello" 的两种方式：

char s[] = "Hello";            char s[6] = {'H','e','l','l','o','\0'};

printf("%s", str); 中，str 必须是 以\0结尾的字符数组。

若 char str[10];，则 scanf("%s", str); 最多能输入 9 个字符（不含结束符）。

以下代码的输出是什么？

int a[4] = {5, 4, 3, 2}; for (int i = 3; i >= 0; i--) printf("%d ", a[i]);

答案：2 3 4 5

以下代码的输出是什么？

char s[] = "Hello"; 

s[2] = '\0'; 

printf("%s", s);                          

答案：He

以下代码是否存在错误？若有，请修正。

int a[2][3] = {{1,2}, {3,4,5}}; 

printf("%d", a[1][2]);                           

答案：无错误，输出5

以下代码的功能是什么？

char str[100]; gets(str); int len = 0; while (str[len] != '\0') len++; printf("%d", len); 

答案：计算输入字符串的长度（不包含结束符）

编写程序，输入5个整数存入一维数组，输出最大值和最小值。

#include <stdio.h> int main() { int a[5], max, min; for (int i = 0; i < 5; i++) scanf("%d", &a[i]); max = min = a[0]; for (int i = 1; i < 5; i++) { if (a[i] > max) max = a[i]; if (a[i] < min) min = a[i]; } printf("最大值：%d，最小值：%d", max, min); return 0; }                   

编写程序，计算二维数组（3x3）对角线元素之和。

#include <stdio.h> int main() { int a[3][3] = {{1,2,3}, {4,5,6}, {7,8,9}}; int sum = 0; for (int i = 0; i < 3; i++) sum += a[i][i] + a[i][2-i]; if (3 % 2 != 0) sum -= a[1][1]; // 避免中心元素重复相加 printf("和为：%d", sum); return 0; } 

编写程序，输入一个字符串，统计其中大写字母的个数。

#include <stdio.h> int main() { char s[100]; int count = 0; gets(s); for (int i = 0; s[i] != '\0'; i++) { if (s[i] >= 'A' && s[i] <= 'Z') count++; } printf("大写字母个数：%d", count); return 0; } 

编写程序，将两个字符数组拼接为一个字符串（不得使用库函数）。

#include <stdio.h> int main() { char s1[100], s2[100], result[200]; int i = 0, j = 0; gets(s1); gets(s2); while (s1[i] != '\0') { result[i] = s1[i]; i++; } while (s2[j] != '\0') { result[i + j] = s2[j]; j++; } result[i + j] = '\0'; printf("拼接结果：%s", result); return 0; } 

用函数实现模块化程序设计

以下关于无参函数定义正确的是（A）

A. void func() {}             B. int func {}           C. func() {}         D. void func(int) {}                        

函数调用时，形参和实参的关系是（C）

A. 形参是实参的别名                             B. 形参和实参共享内存

C. 形参是实参的临时拷贝                     D. 形参必须在函数调用前初始化       

以下函数原型的声明正确的是（B）

A. func(int a, b);                 B. void func(int, int);        

C. int func(a, b);                 D. void func(int a; int b);             

以下代码的输出是（A）

void func(int x) { x = 10; } int main() { int a = 5; func(a); printf("%d", a); return 0; } 

A. 5                B. 10              C. 编译错误            D. 随机值              

以下关于递归函数的描述，错误的是（C）

A. 必须包含终止条件                  B. 每次递归会创建新的栈帧

C. 递归可以替代所有循环         D. 递归可能导致栈溢出           

以下代码的输出是（C）

int func(int arr[]) { return sizeof(arr); } int main() { int a[5]; printf("%d", func(a)); return 0; } 

A. 5                B. 20              C. 4（指针大小）             D. 编译错误           

以下变量的作用域是全局的是（B）

A. 函数内定义的static变量      B. 函数外定义的int变量           

C. 函数内定义的auto变量        D. 函数参数           

static关键字修饰局部变量时，变量的生命周期是（B）

A. 函数调用期间              B. 程序运行期间   C. 文件作用域内            D. 代码块内           

以下代码的输出是（A）

int x = 5; void func() { static int x = 1; x++; printf("%d ", x); } int main() { func(); func(); return 0; } 

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

以下关于外部函数的描述，正确的是（ ）

A. 只能在定义的文件中使用                           B. 使用extern声明         

C. 默认作用域为当前文件                                 D. 不可被其他文件调用  答案：B

函数原型声明的作用是 告知编译器函数的存在及其参数类型。

函数调用方式包括：传值调用，引用调用，传地址调用。

局部变量的默认存储类别是 auto。

若函数返回类型为void，则表示 函数不返回任何值。

递归函数计算阶乘的终止条件是 n == 0 || n == 1。

在函数中修改全局变量会 直接影响全局作用域中的变量值。

使用register关键字声明的变量建议存储在 寄存器 中。

以下代码的输出是什么？

void swap(int a, int b) { int t = a; a = b; b = t; } int main() { int x = 3, y = 5; swap(x, y); printf("%d %d", x, y); return 0; } 

答案：3 5（形参是实参的拷贝，交换不影响实参）

以下代码的输出是什么？

int func(int n) { if (n <= 1) return 1; return n * func(n - 1); } int main() { printf("%d", func(4)); return 0; } 

答案：24（计算4的阶乘）

以下代码是否存在错误？若有，请修正。

extern void print(); int main() { print(); return 0; } void print() { printf("Hello"); }       

答案：无错误。extern声明允许跨文件调用，此处函数定义在调用之后，需提前声明。

以下代码的功能是什么？

void reverse(int arr[], int n) { for (int i = 0; i < n/2; i++) { int temp = arr[i]; arr[i] = arr[n-i-1]; arr[n-i-1] = temp; } }   

答案：将数组元素逆序存放。

编写函数isPrime，判断一个整数是否为素数。

#include <stdio.h> int isPrime(int n) { if (n <= 1) return 0; for (int i = 2; i*i <= n; i++) if (n % i == 0) return 0; return 1; } int main() { int num; scanf("%d", &num); printf(isPrime(num) ? "是素数" : "不是素数"); return 0; } 

编写递归函数计算斐波那契数列第n项。

#include <stdio.h> int fib(int n) { if (n <= 1) return n; return fib(n-1) + fib(n-2); } int main() { int n; scanf("%d", &n); printf("第%d项：%d", n, fib(n)); return 0; } 

编写函数，将一维数组的所有元素加倍（数组作为参数传递）。

#include <stdio.h> void doubleArray(int arr[], int n) { for (int i = 0; i < n; i++) arr[i] *= 2; } int main() { int a[] = {1, 2, 3, 4, 5}; int len = sizeof(a)/sizeof(a[0]); doubleArray(a, len); for (int i = 0; i < len; i++) printf("%d ", a[i]); return 0; } 

编写程序，使用静态局部变量统计函数被调用的次数。

#include <stdio.h> void func() { static int count = 0; count++; printf("调用次数：%d\n", count); } int main() { func(); func(); func(); return 0; } 

善于利用指针

以下关于指针的描述，正确的是（B）

A.指针变量存储的是变量的值               B.指针变量存储的是变量的地址

C.指针变量的类型必须与指向的变量类型一致        

D.指针变量可以直接进行加法运算                 

只能与整型数据加减，两个指针可以进行减法运算。

以下代码的输出是（A）

int a = 10; 

int *p = &a; 

printf("%d", *p); 

A. 10              B. a的地址             C. 随机值               D. 编译错误          

以下指针变量定义正确的是（B）

A. int p;                    B. int *p;                   C. int &p;                 D. *int p;                 

若int arr[5] = {1,2,3,4,5};，则*(arr + 2)的值是（C）

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

以下关于字符指针和字符数组的区别，错误的是（C ）

A. 字符指针可以指向字符串字面量                B. 字符数组名是常量指针

C. 字符指针可以直接赋值字符串        D. 字符数组需要分配固定内存

以下代码的输出是（C）

char str[] = "Hello"; 

char *p = str; 

printf("%c", *(p + 3)); 

A. H               B. e                C. l                 D. l                

函数指针的定义形式是（A ）

A. int (*p)(int, int);               B. int *p(int, int);        

C. int (p)(int, int);                 D. int *p(int, int);             

以下代码的输出是（B）

int a = 5, b = 10; 

int *p1 = &a, *p2 = &b; 

*p1 = *p2; 

printf("%d", a); 

A. 5                B. 10              C. a的地址             D. 编译错误           

以下关于指针数组的描述，正确的是（A）

A. int *arr[5]; 是包含5个整型指针的数组

B. int (*arr)[5]; 是包含5个整型指针的数组

C. 指针数组的每个元素必须是同一类型

D. 指针数组名是常量指针             

每个元素必须具有相同的指针类型，但可以指向不同类型的数据。

void*可以指向任意类型的数据。       

以下代码的输出是（A）

int x = 5;     int *p = &x;           int **pp = &p;      printf("%d", **pp); 

A. 5                B. p的地址             C. x的地址             D. 随机值              

指针变量的定义形式为 类型 *变量名;。

取地址运算符是 &，指针运算符是 *。

若int a[3][4];，则a[1][2]的地址可以通过 *(a + 1) + 2 表示。

字符串的引用方式包括 字符数组 和 字符指针。

函数指针调用函数的语法是 (*指针变量)(参数列表)。

返回指针值的函数定义形式为 类型 *函数名(参数列表) { ... }。

以下代码的输出是什么？

int a = 5, b = 10; void swap(int *x, int *y) { int t = *x; *x = *y; *y = t; } int main() { swap(&a, &b); printf("%d %d", a, b); return 0; } 

答案：10 5

以下代码的输出是什么？

char *str = "Hello"; 

printf("%c", str[2]); 

答案：l

以下代码是否存在错误？若有，请修正。

int *p; 

*p = 10; 

答案：错误：未初始化的指针解引用。修正为：

int a; 

int *p = &a; 

*p = 10; 

以下代码的功能是什么？       

int sum(int *arr, int n) { int s = 0; for (int i = 0; i < n; i++) s += arr[i]; return s; }   

答案：计算一维数组所有元素的和。

编写函数，通过指针交换两个整数的值。

#include <stdio.h> void swap(int *a, int *b) { int temp = *a; *a = *b; *b = temp; } int main() { int x = 3, y = 5; swap(&x, &y); printf("x=%d, y=%d", x, y); return 0; } 

编写程序，使用指针遍历一维数组并输出所有元素。

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

编写函数，返回两个整数中的较大值地址。

#include <stdio.h> int *max(int *a, int *b) { return (*a > *b) ? a : b; } int main() { int x = 10, y = 20; int *result = max(&x, &y); printf("较大值：%d", *result); return 0; } 

编写程序，使用指针数组存储多个字符串并输出。

#include <stdio.h> int main() { char *strs[] = {"Apple", "Banana", "Cherry"}; for (int i = 0; i < 3; i++) printf("%s\n", strs[i]); return 0; } 

用户自己建立数据类型

以下结构体声明正确的是（D）

A. struct Student { int id; char name[20]; };             B. struct { int id; } Student;        

C. Student struct { int id; };                                        D. struct Student { int id; };                    

结构体变量的初始化方式正确的是（A）

A. struct Point { int x, y; } p = {1, 2};     B. struct Point p = {1, 2}; 

C. Point p = {1, 2};                                   D. struct p = {1, 2};         

以下共用体的定义正确的是（A）

A. union Data { int a; float b; char c; };            B. struct Data { int a; float b; };             

C. union { int a; };                                               D. union Data = { int a; };            

共用体的特点是（A）

A. 所有成员共享同一内存空间                  B. 成员内存空间独立   

C. 可以同时存储多个成员的值                  D. 成员类型必须相同 

枚举类型默认从哪个值开始递增？（A）

A. 0                B. 1                C. 随机值               D. 必须显式指定            

以下枚举定义正确的是（A）

A. enum Week { Mon, Tue, Wed };                     B. enum { Mon, Tue, Wed } Week;

C. enum Week = { Mon, Tue, Wed };                D. Week enum { Mon, Tue, Wed };       

以下关于typedef的描述，正确的是（B）

A. 用于定义新变量                      B. 可以简化复杂类型的声明  

C. 不能用于结构体                      D. 会分配额外内存         

以下代码的输出是（A）

union Data { 

    int a; 

    char b; 

} d; 

d.a = 65; 

printf("%c", d.b); 

A. A                B. 65              C. 随机字符            D. 编译错误           

结构体成员的访问方式是（A）

A. 结构体变量.成员名                         B. 结构体变量->成员名 

C. 成员名.结构体变量                        D. *结构体变量.成员名               

以下代码中，typedef的作用是（B）

typedef struct Node { 

    int data; 

    struct Node *next; 

} ListNode; 

A. 定义一个新结构体类型                 B. 将struct Node重命名为ListNode 

C. 声明一个全局变量                        D. 定义联合体  

结构体声明的基本形式是 struct 结构体名 { 成员列表 };。

共用体的所有成员共享 同一块内存空间。

枚举常量默认从 0 开始递增。

使用typedef将int重命名为Integer的语句是 typedef int Integer;。

结构体数组的初始化示例：

struct Student { 

    int id; 

    char name[20]; 

} students[2] = { {1, "Alice"}, {2, "Bob"} }; 

共用体变量的成员赋值会 覆盖之前的值。

以下代码的输出是什么？

#include <stdio.h> struct Point { int x; int y; }; int main() { struct Point p = {3, 4}; printf("坐标：(%d, %d)", p.x, p.y); return 0; }   

答案：坐标：(3, 4)

以下代码的输出是什么？

#include <stdio.h> union Data { int a; float b; }; int main() { union Data d; d.a = 10; d.b = 3.14; printf("%d", d.a); return 0; }   

答案：输出不确定（共用体成员覆盖导致数据损坏）

以下代码是否存在错误？若有，请修正。

typedef struct { int id; char name[20]; } Student; Student s = {101, "Tom"};     

答案：无错误。

以下代码的功能是什么？

enum Color { RED, GREEN, BLUE }; 

int main() { 

    enum Color c = GREEN; 

    printf("%d", c); 

    return 0; 

}                    答案：输出枚举常量GREEN的值，结果为1。

定义一个结构体Book，包含书名（字符串）和价格（浮点数），并初始化两本书。

#include <stdio.h> struct Book { char title[50]; float price; }; int main() { struct Book books[2] = { {"C Programming", 99.5}, {"Data Structures", 120.0} }; for (int i = 0; i < 2; i++) printf("书名：%s，价格：%.2f\n", books[i].title, books[i].price); return 0; } 

使用共用体实现一个变量既能存储整数，又能存储字符。

#include <stdio.h> union Data { int num; char ch; }; int main() { union Data d; d.num = 65; printf("字符：%c\n", d.ch); return 0; } 

定义枚举类型Week，包含星期一到星期日，并输出星期三的值。

#include <stdio.h> enum Week { Mon, Tue, Wed, Thu, Fri, Sat, Sun }; int main() { printf("星期三的值：%d", Wed); return 0; } 

使用typedef简化结构体声明，并定义一个链表节点。

#include <stdio.h> typedef struct Node { int data; struct Node *next; } ListNode; int main() { ListNode node1 = {10, NULL}; ListNode node2 = {20, &node1}; printf("节点2的值：%d", node2.data); return 0; }

总结

复试考试一般不会考太难的题目，把下面这些题目都搞懂就差不多了，可以通过在做题的过程中回顾知识点

我当时在考试的过程中还以为题目出错了，回去发现小丑竟是我自己（我以为这个二维数组等价成int arr[4][4]={{1,2,3},{4,5,6},{7},{8},{9}};，然而并不是），所以虽然在复习前有很多不会的，但是只要认真修正还是可以取得不错从成绩。

#include<stdio.h>int main(){int arr[4][4]={{1,2,3},{4,5,6},7,8,9};printf("%d",arr[2][1]);return 0;
}

C语言复习题_c语言已知整型数组a长度为15,其中保存了10个数,并且这些数 在数组中是有序存放的-CSDN博客https://blog.csdn.net/weixin_64066303/article/details/130682554?spm=1001.2014.3001.5502