C语言单选题题库总结
开始考研的刷题库了，有很多单选题，我会总结上每一道题的知识点，进行记录。纯概念博客，师傅们图一乐即可。
一 c语言概述
1
1、C程序中main函数的位置（C）
A、必须在最开始 B、必须在系统库函数后面
C、可以在自定义函数后面 D、必须在最后
c语言中main函数的位置可以任意位置．在执行一个c语言编写的程序时，main函数就相当于是执行程序的入口．只要是没有语法和逻辑上的错误，main函数可以放在任意位置．
2
2、下面关于C语言用户标识符的描述，正确的是（D）
A、不能区分大小写 B、用户标识符不能描述常量
C、类型名也是用户标识 D、用户标识符可以作为变量名
标识符由字母、下划线、数字这三个方面组成，但开头必须是字母或下划线
标识符不能使用系统法保留的关键字
C语言中标识符区分大小写
用户标识符可以作为变量名
3
3.关于C语言的叙述中，不正确的是（D）
A. C程序可由一个或多个函数组成
B. C程序必须包含一个main（）函数
C. C程序的基本组成单位是函数
D. 注释说明只能位于一条语句的后面
C语言程序是由函数构成的，函数是C程序的基本组成单位.
注释可以随处
4
4.若有说明语句：char C=‘\95’;则变量C包含(A)个字符
A.1 B.2 C.3 D.语法错误
字符常量 '\95' 使用八进制表示
字符常量在存储时只占用一个字节的内存空间，因此变量 C 仅包含一个字符。所以，变量 C 包含 1 个字符。
很多答案都说是语法错误，我也搞不懂几把哪里错了。
#include <stdio.h>
int main(void) {
char C = '\95';
printf("%d", sizeof(C));
return 0;//无语，这些题库能不能好一点啊
}//运行输出是1
5
5.结构化程序设计不包括（A）
A.最优化
B自顶而下，逐步细化
C模拟化设计
D结构化编码
结构化程序设计的设计方法包括下面四个，自顶向下，逐步细化，模块化，结构化编码
6
6.结构化程序设计的三种基本语句是(C)
A.函数结购 分支结构 判断结构
B.函数结构 嵌套结构 平行结构
C.顺序结构 分支结构 循环结构
D.分支结构 循环结构 嵌套结构
结构化程序设计的三中基本语句：顺序结构，选择结构（分支结构），循环结构
7
7.关于C语言数据类型的叙述,正确的是(C)
A.枚举类型不是基本类型
B.数组不是构造类型
C.变量必须先定义后使用
D.不允许使用空类型
枚举类型是一种基本数据类型而不是构造数据类型.
C语言数据类型中构造类型包括三种：数组类型 结构类型 联合类型
C语言有四种基本数据类型：整型，浮点型，指针，聚合类型。
c语言没有空类型。也就是void a; 是不行的,但允许有void指针,void* p;可行,
变量必须先定义后使用
8
关于C语言的源程序的叙述中,错误的是(C)
A.C语言的源程序由函数构成
B.main函数可以书写在自定义函数之后
C.必须包含有输入语句
D.一行可以书写多个语句
C语言的源程序并不一定要包含输入语句。不同的程序可能具有不同的输入方式，如从命令行参数读取、从文件中读取等。
9
9.下面叙述中，（A）不是结构化程序设计中的三种基本结构之一
A.数据结构 B.选择结构 C.循环结构 D.顺序结构
结构化程序设计的三中基本语句：顺序结构，选择结构（分支结构），循环结构
10
10.char 型变量存放的是（A）
A.ASCⅡ码值
B.字符本身
C十进制代码值
D十六进制代码值
c语言中,char型数据是“ASCII码”形式存储的
11
11.已有如下定义和输入语句
int a; char c1,c2;
scanf(“%d，%c，%c”, ＆a, ＆c1, ＆c2);
若要求a、c1、c2的值分别为10、A和B，正确的数据输入是（ B ）
A．10AB
B．10,A,B
C．10A B
D．10 AB
注意哈，由于scanf里面存在逗号，所以这道题才选B。
如果scanf没有逗号的话就选A
#include <stdio.h>
//实例程序
int main(void) {
int a; char c1, c2;
scanf(" %d,%c,%c", &a, &c1, &c2);
printf("%d\n%c\n%c", a, c1, c2);
return 0;
}
12
12.以下叙述不正确的是（ D ）
A、C程序的执行总是从main函数开始
B、一个C源程序必须包含一个main函数
C、C语言程序的基本组成单位是函数
D、在编译C程序源程序时，可发现注释中的拼写
A. C程序的执行总是从 main 函数开始，main 函数是程序的入口。
B. 一个C源程序必须包含一个 main 函数，因为程序的执行从 main 函数开始。
C. C语言程序的基本组成单位是函数，C程序是由多个函数组成的。
D. 编译C程序时不会检查注释中的拼写。注释是用来提供对代码的说明和解释，编译器在编译阶段会忽略注释，不对其进行处理。
13
13.已知如下定义和输入语句：
int a, b;
scanf (“%d, %d”，＆a, ＆b);
若要求a、b的值分别为10和20，正确的数据输入是（B）
A、10 20
B、10，20
C、a=10, b=20
D、10；20
还是一样的，scanf里面存在逗号。
14
14、在C语言源程序中，以下叙述正确的是（C）
A、main函数必须位于文件的开头
B、每行只能写一条语句
C、程序中的每一语句可以写成几行
D、每个语句的最后必须有点号
A.main不一定非要在开头
B.每行可以写多条语句
C. 正确，C语言中的语句可以跨越多行书写。使用反斜线（\）来表示下一行是当前语句的延续。这种写法可以提高代码的可读性。
D. 每个语句的最后必须有分号（;）而不是点号。分号用来表示语句的结束。
15
15.对于C语言源程序,以下叙述错误的是( C )
A.可以有空语句
B.函数之间是平等的,在一个函数内部不能定义其它函数
C.程序调试时如果没有提示错误,就能得到正确结果
D.注释可以出现在在语句的前面
1.可以有空语句，即只包含一个分号的语句。它们在某些情况下可能是有用的，例如在某个条件下不需要执行任何操作。
2.在C语言中，函数是独立的代码块，不能在函数内部定义其他函数。函数的定义必须是独立于其他函数之外的。
3.c语言的函数不可以嵌套定义
4.注释可以出现在语句的前面。C语言中，注释是用来给代码添加说明、解释和注解的，编译器在编译时会忽略注释。
16
16．下面叙述中，（A）不是结构化程序设计三种基本结构的共同特点
Ａ．先判断后执行
Ｂ．单入口，单出口，
Ｃ．程序中没有执行不到的语句
Ｄ．无死循环
A. 先判断后执行并不是结构化程序设计三种基本结构（顺序结构、选择结构、循环结构）的共同特点。先判断后执行是指在执行某一代码块之前进行条件判断，根据判断结果决定是否执行。这是选择结构（if语句）的特点，不适用于其他两种结构。
B. 单入口，单出口是结构化程序设计三种基本结构的共同特点。这表示程序的执行都从一个确定的入口（如main函数）开始，并且从该入口输出结果，只有一个出口。
C. 程序中没有执行不到的语句是结构化程序设计的特点，保证所有的代码都能被执行到。这也是为了避免程序中出现悬挂语句或无效代码。
D. 无死循环也是结构化程序设计的特点，避免程序陷入无限循环而无法退出。
17
17.若有定义:int x=1234,y=123,z=12;则语句printf(“%4d+%3d+%2d”,x,y,z);运行后的输出结果为(D)
A.123412312
B. 12341234123412341231231231212
C.1234+1234+1234
D.1234+123+12
根据printf函数的格式化字符串”%4d+%3d+%2d”，它指定了输出3个整数，并且左对齐输出，总宽度分别为4、3和2个字符。
数据类型，运算符和表达式
1
1、若定义：int x=2; y=3; float i； 则以下符合C语言语法的表达式是（B）
A、x=x*3=2
B、x=(y==1)
C、i=float(x)
D、i%(-3)
D.在C语言中,取余操作符(%)的操作数只能是整型
B. 表达式 “x = (y == 1)” 中括号内的表达式 “y == 1” 是一个条件表达式，返回一个布尔值（真或假），然后将布尔值赋给整数变量 x，这是符合C语言的语法。
？这道题我不知道C错哪了，
#include <stdio.h>
int main(void) {
int x = 2, y = 3; float i;
i = float(x);
x = (y == 1);
return 0;
}//这jb也没报错啊我草，这些c语言老师不会出题就别出可以吗。
2
2、若有定义：int a=5, b=2, c=1；则表达式a-b<c||b==c的值是（A）
A、0 B、1 C、2 D、-1
很简单的一道题，左右条件都为假，中间那个是逻辑或。
逻辑或运算符的短路特性是，只要在整个表达式中发现了一个为真的条件，就不再继续计算剩下的表达式。也就是一个为真结果就为真
3
3、若有68定义：float x=3.5; int z=8; 则表达式x+z%3/4的值是（B）
A、3.75 B、3.5 C、3 D、4
根据给定的定义：float x=3.5; int z=8; 我们计算表达式x+z%3/4的值。
首先，根据运算符的优先级，我们先计算取余运算 z%3：
z%3 = 8%3 = 2 （8除以3的余数）
然后，我们计算3除以4的结果：
3/4 = 0 （这里由于除法运算涉及到整数，因此结果会取整数部分）
最后，我们将结果2加上浮点数 x 的值：
2+3.5=5.5
因此，表达式x+z%3/4的值是5.5。
所以，正确答案是选项 B. 5.5。
4
4.若有定义：int a=1，b=2，c=3；语句++a||++b＆＆++a运行后b 的值为（C）
A．1 B.0 C.2 D.3
可以看到这个逻辑与和逻辑或都是从左到右的，然后看逻辑或的短路特性，一个为真就不会执行接下来的东西了。
由于第一个操作数的结果为真（非零），整个表达式的结果也为真（非零），此时不会再执行后续的操作。
所以最后b的值依然是2.
5
9.对于整型变量x，下述计语句（B）与赋值句：x=x%2==0?1:0;不等价
A.if（x%2！=0）x=0；else x=1；
B.if（x%2）x=1；else x=0；
C.if（x%2= =0）x=1；else x=0；
D.if（x%2==1） x=0；else x=1；
这个很简单啊，我加上括号就好了x=(x%2==0?1:0);
这样理解，然后如果x对2取余，结果为0，x的值就是1.
6
12.下面语句正确的是（ B C ）
A.int *P；*P=20;
B.char *s=“abcdef”；printf（“%s\n”,s）;
C.char str[]=“abcdf”；
printf（“%s”,str）；
D.char str[]={‘a’,’b’,’c’};printf(“%s”,str);
A.在代码中，定义了一个整型指针变量 P，但是没有为其分配内存空间。
然后，执行了 *P = 20; 这个语句，它会尝试将一个值赋给未初始化的指针 P 所指向的内存地址。
由于指针 P 没有被正确初始化，它的值是不确定的，可能指向的是未分配的内存地址，因此这段代码是有严重错误的。
这样的操作可能导致程序出现未定义的行为，比如崩溃或错误的结果。
#include <stdio.h>
#include <stdlib.h>
int main(void) {
int* P;
int num = 20;
P = #
*P = 20;
printf("%d", *P); // 输出 20
return 0;
}//这才是A的正确答案
D。在 %s 的格式控制符中，需要传入指向字符串的指针。而不是传入一个数组的指针。
反正答案都输选B,那就bbbbbb。
不是，我就搞不懂了，这些b题为啥我有些就是编译报错呢。
7
13.若有定义:intａ＝２；则正确的赋值表达式是（Ａ）
Ａ.ａ- =(a*3) B.double(-a) C.a* D.a*4=3
这个不多解释，其他都不是正常的赋值语句好吧。
A最后结果是，-4
8
15.对于基类型相同的两个指针变量之间，不能进行的运算是（C）
A.＜ B.＝ C.﹢ D.﹣
选项 A 的 “<” 运算符表示比较两个指针的值的大小关系，选项 B 的 “=” 运算符用于指针的赋值，选项 D 的 “－” 运算符用于计算两个指针之间的距离。
“+ “ 运算符在指针之间进行运算是非法的。指针的相加操作是未定义的行为
9
16.若有定义:int a;则语句a=(3*4)+2%3;运行后a的值为(B)
A. 12 B.14 C.11 D.17
这个不多说，前面是12，后面是2，加起来14
10
17.下面叙述中,错误的是(A)
A.其算术运算对象不包含函数
B.%(模拟运算符)的运算对象只能为整型量
C.算术运算的结合方向是“自左向右”
D.自加和自减运算符的结合方向是“自右向左”
A.是错误的。算术运算可以应用于包含函数的算术运算对象，只要在运算之前将函数计算为相应的值。在确保函数的返回值具有适当的类型后，可以将其用作算术运算的操作数。例如，可以将函数的返回值与其他操作数进行加法或乘法运算。
D.自加 (++) 和自减 (–) 运算符的结合方向是从右到左。这意味着如果同时存在多个自加或自减运算符，则从最右边的运算符开始逐个执行。
11
18.已知int a=‘R’；则正确的表达式是（A）
A.a%10
B.a=int（3e2）
C .2＊a=a++
D.a=a+a=a+3
B选项中，使用C++风格的强制类型转换语法 (int)，的确在一些编译器中是可以编译通过的，但这并不符合C语言的标准。在C语言中，应该使用C风格的强制类型转换语法 (int)。
12
20.以下的计语句中,x的值一定被重新赋值的是(B)
A.if(x==y) x+=y;
B if(x＞y＆＆x!=y);x+=y;
C.if(x!=y) scanf(“%d”,＆x) else scanf(“%d”,＆y);
D.if（x＜y） {x++；y++}
B if(x＞y＆＆x!=y);x+=y; 关键是中间有个;号, 导致if语句对后面的那个语句不起作用.这样考眼力的题目没什么意思（笑死我了）
13
21.设有double型变量a，b，c，e均有值，对代数式（3ae）/（bc），不正确的语言表达式是（C）
A.a/b/c*e*3 B.3*a*e/b/c C.3*a*e/b*c D.a*e/c/b*3
加减乘除都是从左到右，先计算乘除取余。
所以c其实指的是（3aec）/（b）
14
22.以下运算符中优先级最高的是(D)
A.＞ B.|| C.＆＆ D.+
记住，大于在加后面，剩下两个优先级其实很低。
15
23.若有自定义:int a,b;double x.,则以下不符合C语言的表达是(A)
A.x%(-3) B.a+=-2
C.a=b=2 D.x=a+b
取余的操作只能作用于整数
16
24.若有定义:int a[3] [3];则表达式＆a[2][1]-a的值为(A)
A.7 B.8 C.6 D.9
二维数组其实也是线性存储，题目中的减号之前也提到过，计算的是两个内存地址相差的数量。a指的是首字母的地址。
这里每一行是三个元素，a[2][1]在第三行第一个，中间就是查了1+3+3个元素，所以选7.
（什么狗题，明明int是四个字节，应该是7*4=28才对。。）
17
25.以下（D）是正确的变量名
A.a.bee B.-P11
C.int D.P＿11
变量名只能由字母和下划线和数组组成，然后只能由字母和下划线开头。不能和关键字重复。
18
26.若有定义：int a=1，b=2 ，c=3，d=4，x=5，y=6 则表达式（x=a＞b）＆＆（y=c＞b）的值为（A）
A.0 B.1 C. 5 D.6
这个更简单，判断一下即可，x是假，y是真。一个真一个假的逻辑或，一假即为假。
19
27.以下（D）是正确变量名
A.5f B.if C.f.5 D._f5
变量名必须以字母或下划线 _ 开头，后面可以跟着字母、数字或下划线。它也不能是C语言的关键字。
20
28.若有定义：int x=3，y=4，z=5 则值为0的表达式是（D）
A.‘x’＆＆‘y’
B. x＜=y
C. x||y=z＆＆y-z
D. ！（（x＜y）＆＆！z||1）
#include <stdio.h>
int main(void) {
int x = 3, y = 4, z = 5;
int test = !((x < y) && !z || 1);
printf("%d", test);
return 0;
}//返回值为0
取非!在逻辑与或的前面，
所以先计算最右边的！，!z || 1这个表达式就是1，因为逻辑或有一真即为真，然后左边(x < y)是真的，括在一起，两个真的逻辑与，真。最后对这个!(ture)最后就是假，所以输出为0
21
29.若有定义：int x,a；则语句x=(a=3,a+1)；运行后x、a的值依次为（ C ）
A．3，3 B．4，4
C．4，3 D．3，4
在这个语句中，我们使用了逗号操作符 ,。逗号操作符可以用来在一个表达式中使用多个子表达式，并且每个子表达式都会被依次计算，但最终的结果是最后一个子表达式的值。
首先，a = 3 将 a 的值设置为 3。然后，a + 1 计算出 4，这个值被赋给了 x。所以最终的结果是 x = 4 和 a = 3。
22
30.若有定义：int a,b；则表达式(a=2,b=5,a*2,b++,a+b)的值是（ B ）
A．7 B．8 C．9 D．10
从左往右执行哈，a=2,b=5，然后b加了一个，b=6，最后a+b=8
23
31.若有定义：int a=2,b=3;float x=3.5,y=2.5;则表达式(float)(a+b)/2+(int)x%(int)y的值是（A）
A．3.5 B．3.0
C．2.5 D．2.0
计算顺序应该是(float)(a+b)/2然后再加上(int)x%(int)y
(5/2)+(3%2)=3.5
24
32. 以下（B）是错误的整型常量
A、-0xcdf B、018 C、0xe D、011
当数字以0开头时，C语言将其解释为八进制数。在八进制表示中，有效数字的范围是0到7。因此，八进制常量的每个数字都必须在0到7之间。
在选项B中，常量是018。这个常量的第一个数字是0，表示八进制。接下来的数字1是有效的，但是后面的8超出了八进制的范围。因此，018是错误的整型常量。
在C语言中，整型常量遵循特定的规则。它们可以是十进制、八进制或十六进制的表示形式。
以0为前缀表示八进制数，以0x或0X为前缀表示十六进制数。
选项 A. -0xcdf 是正确的十六进制负数常量；
选项 B. 018 是错误的，因为0后面不能紧跟非零数字的八进制常量表示；
选项 C. 0xe 是正确的十六进制常量；
选项 D. 011 是正确的八进制常量。
25
33.语句a=(3/4)+3%2; 运行后，a的值为（B）
A、0 B、1 C、2 D、3
首先，我们计算表达式 (3 / 4)。在整数除法中，如果除法的结果不能整除，则舍去小数部分。因此，3 / 4 的结果为 0。
然后，我们计算表达式 3 % 2，它代表取余运算。3 除以 2 的余数为 1。
26
34.设整形变量a为5， 使b不为2的表达式是（C）
A、b=(++a)/3 B、b=6-(--a)
C、b=a%2 D、b=a/2
C选项明显b是1
27
35、已知char a=’R’；则正确的赋值表达式是（A）；
A、a=(a++)% 4 B、a+2=3
C、c a+=256-- D、a=‘\078’
a是char类型的数据，但是在c语言中，char也被当做是int类型存储，所以可以进行取余操作。
D:当数字以0开头时，C语言将其解释为八进制数。在八进制表示中，有效数字的范围是0到7。
28
36.下面叙述正确的是（B）
A、2/3与2.0/3.0等价 B、（int）2.0/3与2/3等价
C、++5与6等价 D、‘A’与“A”等价
C. ++5与6等价：这个叙述是不正确的。++5是错误的语法，++是一个递增运算符，应该与变量一起使用。而6是一个字面常量，不是一个变量，不能与++运算符一起使用。
D. ‘A’与“A”等价：这个叙述是不正确的。‘A’是一个字符常量，表示一个字符A；而“A”是一个字符串常量，表示一个包含一个字符A的字符串。
29
37、getchar( )函数的功能是从终端输入（D）
A、一个整型量值 B、一个实型变量值
C、多个字符 D、一个字符
getchar()函数是C语言中的标准库函数，它用于从标准输入（终端）获取单个字符，并返回该字符的ASCII值（整数)
30
38、若有定义：int i=7, j=8; 则表达式 i >j||i<j的值为（A）
A、1 B、变量i的值
C、0 D、变量j的值
逻辑或运算符 || 的运算顺序是从左向右。
而且这个逻辑或，只要有一个真就是真的，所以选a啦
31
39、若有定义：int i ，j；则表达式（i=2, j=5, i++, i+j++）的值是（B）
A、7 B、8
C、9 D、10
3+5,括号的顺序是从左往右的
32
40.若希望当a的值为奇数时,表达式的值为”真”,a的值为偶数时,表达式的值为”假”.则不能满足要求的表达式是( C )
A.a%2==1 B.!(a%2==0)
C.!(a%2) D.a%2
c括号里面本来是满足的，加了个！就相反了。
33
41．下面叙述正确的是（ A ）
Ａ．强制类型转换运算的优先级高于算术运算
Ｂ．若a和b是整型变量，(a+b)++是合法的
Ｃ．”A”*＇B＇是合法的
Ｄ．＂A＂+＂B＂是合法的
在C语言中，强制类型转换运算符(type)具有较高的优先级.
若a和b是整型变量，(a+b)++ 是非法的。在C语言中，后缀自增运算符++只能用于变量，而不能用于表达式。
"A" * 'B' 是非法的。C语言中，乘法运算符*只可以用于数值类型的操作数，而不可以用于字符类型的操作数。
在C语言中，字符串类型是用字符数组表示的，而不是简单的字符。字符串常量可以被表示为"A"这样的字符数组，但是不能直接进行加法运算。
34
42．以下程序段运行后变量a的值为（D）
int x=6,y=5;
int a;
a=(--x==y++)?x:y+1;
Ａ．０ Ｂ．１ Ｃ．６ Ｄ．５
括号中的表达是真的，所以会选择x，而x进行过自减操作，所以为5
35
43.下面程序段的运行结果是( D )
int a =5 b=6;printf (“%d”,a/b);
A. 5 B. 6 C. 7 D. 0
整数相除会忽略掉小数部分，所以是0
36
44.以下程序的运行结果是( D )
void main()
{
int a=65;
char c=’A’;
printf(“%x,%d”,a,c);
}
A.65, B.41, C.65,65 D.41,65
%x 的格式说明符用于打印变量 a 的十六进制表示，%d 的格式说明符用于打印变量 c 的十进制表示。
%d：用于打印有符号十进制整数。
%u：用于打印无符号十进制整数。
%f：用于打印浮点数。
%c：用于打印单个字符。
%s：用于打印字符串。
%x 或 %X：用于打印无符号十六进制整数，字母可以是小写或大写。
%o：用于打印八进制整数。
%p：用于打印指针地址。
%e 或 %E：用于打印科学计数法表示的浮点数。
%g 或 %G：根据实际情况自动选择 %f 或 %e 表示浮点数。
%%：用于打印一个百分号。
因此，%x,%d 会将变量 a 的值 65 打印为 41（十六进制表示），变量 c 的值 ‘A’ 打印为 65（十进制表示）。
排除法都选D吧
选择结构程序设计
1
1.C语言对于计嵌套语句的规定：else总是与（B）配对
A.第一个if
B.之前最近且尚未配对
C.缩进位置相同的if
D.之前最近的if
这个是规定哈
2
3、以下程序运行结果是（D）
void main( )
{ int n=5;
if ( n++=6 )
printf( “% d\n” , n);
else
printf ( “%d\n” , ++n );
}
A、4 B、5 C、6 D、7
这个也不用多说，加了两次，第一次判断的时候是先调用再增加。
3
4.以下程序段运行后的值为（ B ）
int a[]={1,2,3},b[]={4,2,5};
int *p,*q;
int i,x;
p=a;q=b;
for(i=0;i<3;i++)
if(*(p+i)==*(q+i))
x=*(p+i)*2;
Ａ．２ Ｂ．４ Ｃ．６ Ｄ．不确定
这个也不多说，是个人就看的出来好吧，大概说说就是p和q都是指向那两个数组头地址的指针，加i就是表示第几个元素。
4
5.若有定义:int a=1,b=2,c=3;则执行以下程序后a,b,c的值分别为( D )
if(a＜b) {c=a,a=b,b=c;}
A.a=1 b=2, c=3 B.a=2 b=3 c=1 C.a=2 b=3 c=3 D.a=2 b=1,c=1
条件打成执行大括号里面的语句，然后就是c=1，a=2,b=1.
直接就选d了
5
6.以下程序的运行结果是（C）
void main ( )
{ int n=‘e’；
switch (n--)
{default: printf (“error”);
case‘a’：
case‘b’: printf(“good”); break;
case‘c’: printf(“pass”);
case‘d’: printf(“warn”);
}
A、error B、good
C、error good D、warn
这个很简单啊，switch会依次执行嘛，遇到break停止。e没有匹配到，就执行默认，然后依次执行。
循环控制
1
1.对于整型变量x，与while（！x）等价的是（B）
A.while（x！=0） B.while（x==0） C.while（x！=1） D.while（～x）
2
2.以下程序运行后，循环体运行的次数为（ B ）
int i=10,x;
for( ;i<10;i++)
x=x+i;
A．10 B．0
C．1 D．无限
你这个i都不小于10，执行个jb
3
3.设有整型变量x，下述语句（ B ）不会出现死循环
A、for( ; ; x+=1);
B、for(; (x=getchar( ))!=‘\n’; );
C、while (1) {x++;}
D、for(x=10; ; x--);
b嘛，一看知道了，当x不等于换行符的时候就执行，是换行符的时候就停止执行。
4
4、在C语言中while循环和do—while循环的主要区别是（ B ）
A、do—while 循环体内可以使用break语句， while循环体内不能使用break语句
B、do—while的循环至少无条件执行一次，while的循环体不是
C、do—while 循环体内可以使用continue语句，while循环体内不能使用continue语句
D、while的循环体至少无条件执行一次，do—while的循环体不是
这个不多说，不知道的立即推好了
5
5、对于整型变量x和y，语句for (x=0, y=0 ; (y!=123) ＆＆(x<4); x++) y++;中的“y++;”被执行（ A ）
A、4次 B、0次
C、123次 D、3次
这个也不多说了好吧，中间是与，但是也没影响，毕竟y加不到123次，只用看x执行了多少次即可。
6
6．以下程序段运行后变量n的值为（ D ）
int i=1,n=1;
for( ; i<3;i++)
{
continue;
n=n+i;
}
Ａ．４ Ｂ．３ Ｃ．２ Ｄ．１
因为continue语句体检结束了循环，所以n的值不变哈，就是还是1.
在程序段中的 for 循环中，使用了 continue 语句，当 continue 被执行时，它会跳过当前循环中剩余的代码，并进入下一次循环迭代。
7
7．设有如下程序段：
int a[3][3]={1,0,2,1,0,2,1,0,1},i,j,s=0;
for(i=0;i<3;i++)
for(j=0;j<i;j++)
s=s+a[i][j];
则执行该程序段后，s的值是（ C ）
Ａ．０ Ｂ．１ Ｃ．２ Ｄ．３
这个双重循环倒是可以一步步的慢慢分析了，第一步的时候i就是0，注意在最外面一层循环结束之前，都不会执行i++所以第一次循环i和j的值都是0不会执行语句。
第二步的时候，i增加了，i为1，j循环就执行1次，执行的时候，i为1，j为0，s=1
第三部的时候，i为2，j就循环执行2此，执行的时候，i为2，j为0，1，s=1+1+0
第四步，i为3，不执行语句。
8
8.以下程序运行结果（C）
void main()
{
int sum=0,item=0;
while(item＜5)
{
item++;
sum+=item;
if(sum＞=6) break;
}
printf(“%d\n”,sum) ;
}
A.10 B.15
C.6 D.7
就是这种题才有意思啊喂，比之前那些文字游戏好玩多了好吧😎
首先就是item为0，开始执行，首先自增为1，然后sun加为1，如果sum大于6就结束，但是不是捏。
然后第2次循环，item为1，进入，然后自增为2.sum增加为3，结束。
第3次循环，item为2，进入，然后自增为3，sum加为6，结束此循环。
输出sum为6
9
9.下面程序运行结果是( A )
int i=0,a[] ={1,2,3,4,5};
do{
a[i]+=10;
}while(a[++i]＞2);
for(i=0;i<5;i++)
printf(“%d”,a[i]);
A.11 2 3 4 5
B.1 2 3 4 5
C.11 12 13 14 15
D.11 12 3 4 5
dowhile形式，会先执行do里面的内容然后再判断哈。
首先给a数组里面第一个元素加了个10.
然后while，++i=1，a[1]=2不执行，然后就跳出循环（者循环里面也没东西啊，注意while后面的分号）
然后执行for循环，循环输出数组中的内容，就是那里面的内容。
10
10.若有定义:int i=0,x=0; int a[3][3]={1,2,3,4,5,6,7,8,9}则以下程序段运行后x的值为( C )
for( ;i＜3;i++) x+=a[i][2-i]；
A.0 B.12
C.15 D.18
for循环，i是0，执行三次。
第一次，i是0，x是3
第二次，i=1，x=3+5
第三次，i=2，x=8+7=15
11
11.以下程序的运行结果是( B )
void main()
{
int sum=0,item=0;
while (item＜5)
{
item++;
sum+=item;
if(sum==5)
break;
}
printf(“%d\n”,sum);
}
A. 10 B.15 C.5 D.6
当sum到5的时候，退出循环。
第一次，item=0，1，sum=1
第二次，item=1，2.sum=1+2
第三次，item=2，3，sum=3+3=6
第四次，item=3，4，sum=6+4
第五次，item=4，5，sum=10+5
第六次，item=5，不循环。输出15
12
12.下面程序段的运行结果是( D )
int i=O, a[]={3,4,5,4,3};
do{
a[i]++;
}while(a[++i]＜5);
for(i=0;i＜5;i++)
printf(“%d”,a[i]) ;
A. 45654 B.34543 C.45554 D.45543
开始分析：
第一次，先把第一个元素变成4，这个时候第二个元素为4，小于5，执行循环
第二次，第二个元素变成5，第三个元素为5，不循环。输出45543
13
13.下面程序段的运行结果是( C )
int i=0,a[]={7,5,7,3,8,3};
do{
a[i]+=2;
}while(a[++i]＞5);
for(i=0;i＜6;i++)
printf(“%d ”,a[i]);
A. 9 7 9 5 10 5 B.9 5 9 3 10 3 C. 9 5 7 3 8 3 D.7 5 7 3 8 3
第一次，先把第一个元素变成9，然后第二个元素5不大于5，不执行循环。
直接进入下面的for循环，循环输出数组中的内容
数组中的内容只修改了第一个元素，所以就是
957383
数组
我是无情的码字机器，我是腱鞘炎单推人😎
1
1、有如下定义 int a[ ][3]={1，2，3，4，5，6，7，8，}；则数组a的行数（ B ）
A、 2 B、 3
C、 4 D、无法确定
每行三个元素，一个一个数不就好，没定义的用0补齐。所以是3行
2
2.以下数组定义中，正确的是（ D ）
A.int a[2] [3]={1，2，3，4，5，6，7}；
B.int a[] []={{1，2，3}，{4，5，6}，{7，8，9}}；
C.int a[2] []={1，2，3，4，5，6}；
D.int a[] [4]={6}；
在 C/C++ 中，如果要声明多维数组并对其进行初始化，每个维度（除了第一维）都需要指定大小。这是因为编译器需要知道每个维度的大小来正确分配内存和处理索引。
反正最后一个必须要有定义，然后A选项中，定义的时候多了个元素。
3
3.若有定义:int a=6,b=2;ch1ar C1=‘a’，C2=‘b’；则表达式a+b%5+C2-C1的值是（ C ）
A .7 B.8
C.9 D表达式错误
‘a’的值97，’A‘的是97.
然后b是98，现在开始算，b%5就是2，所以答案就是，6+2+98-97最后算出来就是9
4
4.若有定义：char str[6]=“abcdm”，*ps，*str2=“abcdef”；正确的是（ B ）
A.stycpy（str1，str2）；
B.表达式strcmp（str1，str2）的值＞0
C.str1=str2；
D.表达式strlen（str1）的值为6
函数解释
strcpy函数是C语言中的字符串函数之一，用于将一个字符串复制到另一个字符串中.
strcmp函数的作用是比较两个字符串，返回一个整数值。具体的返回值有以下几种情况：
如果 str1 和 str2 相等，则返回 0。
如果 str1 大于 str2，则返回一个正整数（大于 0）。
如果 str1 小于 str2，则返回一个负整数（小于 0）。
strlen函数接受一个参数，即需要计算长度的字符串（str），并返回一个 size_t 类型的值，表示字符串的长度。
题目解析
这道题都没说明str1和2到底是谁我们只能猜测前面那个是str1后面那个是str2.然后看我之前解析的函数就可以知道答案了，第一个字符串是比第二个字符串的长度大的所以b返回正值。
5
5.以下能对一维数组a进行正确初始化的语句是（ D ）
A.int a[5]=（0，0，0，0，0，） B.int a[5]=[0]
C.int a[5]={1，2，3，4，5，6，7} D.int a[]={0}
数组只能用花括号定义啊，然后c选项又多定义了2个元素
6
6.以下( A )是不正确的字符串常量
A.‘abc’ B.“12′12” C.“O” D“ ”
A. ‘abc’ 是不正确的字符串常量。在 C 语言中，字符串常量应该使用双引号 “ 来表示，而不是单引号 ‘。单引号用于表示字符常量。
B. “12’12” 是正确的字符串常量。虽然其中包含了单引号字符，但是它是一个有效的字符串，因为它是由双引号包围的。
C. “O” 是正确的字符串常量。它只包含一个字符，由双引号包围。
D. “ “ 是正确的字符串常量，表示一个空字符串。它由双引号包围，但不包含任何字符。
7
7.设有如下定义：char str[8]={“Fujian”}；则分配给数组str的存储空间是（C）字节
A.6 B.7
C.8 D.9
一个字符占一个字节，8个元素就是8个字节
8
8.下列数组定义中,正确的是( A )
A.int a[10]
B.int n=10 a[n];
C.int N=10;int a[N];
D.int n; scant(“%d”,＆n);int a[n]
额第一个怎么看都是正确的吧，第二个的n是什么鬼啊喂！而且如果第二个是对的了那第一个肯定是对的吧喂，出题人是什么脑回路？
最后一个也不说了好吧，第二个是错的你第三个就能对了？
最后一个，C语言中，数组的大小必须是在编译时就确定的，而不能在运行时根据用户的输入来决定。
在 C 语言中，数组的大小必须是一个整型常量表达式。数组的大小应该在编译时就确定。
9
9.若有定义int a[2][3];则对数组元素的非法引用是( D )
A.a[0][1/2] B.a[1][1]
C.a[4-4][0] D.a[0][3]
首先值得注意的是，上面那一题我们也说过了，数组的大小必须是整数常量的表达式，注意是表达式哈。
最后一个，是超出范围引用了。
10
10.若有int a=2 则a=strcmp(“miss”,“miss”)运行后a的值为（B）
A.1 B.0
C.-1. D.2
cmp是比较两个字符串，一样的话就返回0
11
11.以下程序结束后屏幕输出（B）
char str[]=“ab\\cd”;printf(“%d”,strlen(str));
A.4. B.5
C.6 D.7
我草，我要是在考研这道题就错了！！
中间那两个斜杠是转义！！所以其实只有五个字符在里面！
12
12.已知int a[10]；则对a数组元素引用不正确的是（ A ）
A．a[10] B．a[3+5]
C．a[10-10] D．a[5]
第一个明显超出范围了好吧
13
13.设有以下变量定义：
char str1[]=”string”,str2[8],*str3,*str4=”string”;
则（ A ）是正确的
A．strcpy(str1,”china”)； B．str2=”china”；
C．strcpy(*str3,”china”)； D．strcpy(str4[0],”china”)；
B. str2 = "china"; 是错误的语句。在 C 语言中，字符串不能直接用赋值操作符 = 赋值给数组。如果想要将一个字符串的内容赋值给数组，应该使用 strcpy() 函数。
C. strcpy(*str3, "china"); 是错误的语句。由于 str3 是一个指针变量，它指向某个地址。在使用指针指向的地址之前，必须先为其分配内存。否则，将无法使用 strcpy() 函数来复制字符串。
D. strcpy(str4[0], "china"); 是错误的语句。在给定的变量定义中，str4 是一个指向字符串常量的指针，它的内容是只读的，不能对其进行修改。
14
14、以下能对一维数组a进行正确初始化的语句是（ D ）
A、int a[5]=(0, 0, 0, 0, 0); B、int a [s]=[0];
C、int a[5]={1, 2, 3, 4, 5, 6, 7 }; D、int a [ ] = {0};
花括号，c选项超出范围
15
15. 若有定义int a [ ] [ 3 ]={1,2,3,4,5,6,7,8,9};则表达式sizeof(a)/sizeof(a[0])的值为( A )
A、3 B、4 C、5 D、9
9除以3，所以是3
16
16、下列数组定义中，正确的是（ A ）
A. int a[5]={0};
B、int a[ ]={0 1 2};
C、int a[5]=0
D、int a [ ]
第二个看着是对的，但是没有逗号。
17
17、以下数组定义中，正确的是（ D ）
A、int a[2][3]={1,2,3,4,5,6,7};
B、int a[ ][ ]={{1,2,3},{4,5,6}, {7,8,9}};
C、int a[2][ ]={1,2,3,4,5,6};
D、int a[ ][4]={6}
这个学长的答案又错了，答案是D。必须要给最小的那个数组赋值！
18
18.若有定义:int a[3][4]={{1,2},{0},{1,2,3}};则a[1][1]的值为( A )
A.0. B.{1,2} C.1 D.3
这个就是0.别想其他的了哈（你是1？🤗）
19
19.若有定义:int a[3]={0,1,2};则a[1]的值为( B )
A.0 B. 1
C.2 D.3
写错了的自己立即推
20
20．若有定义：int a[5]={1,2,3,4,5};则语句a[1]=a[3]+a[2+2]-a[3-1];运行后a[1]的值为（ A ）
Ａ．６ Ｂ．５ Ｃ．１ Ｄ．２
大概就是4+5-3所以是6
21
21.有如下定义:char str[6]={‘a’,‘b’,‘\0’，‘d’，‘e’，‘f’}；则语句printf(“%s”,str);的输出结果是( D )
A.ab\ B.abdef
C.ab\0 D.ab
\0是结束符号。别忘了哈
22
22.定义char a[]=“abcdef”；char b[]=“xyz”;以下程序运行后输出（ B ）
strcpy（a，b）；
printf（“%c”，a[2]）；
A. c B. z C.\0 D.d
#include <stdio.h>
#include <string.h>
int main() {
char a[] = "abcdef";
char b[] = "xyz";
strcpy(a, b);
printf("%s",a);
return 0;
}//输出xyz
这个是直接把那个b里面的内容弄进去了，直接覆盖了。所以答案选B
23
23、以下程序段运行后屏幕输出为（ A ）
char str[80];
strcpy(str, “hello”);
printf( “%d” , strlen (str));
A、5 B、6 C、7 D、80
在给定的程序段中，字符数组 str 的长度为 80。而使用 strcpy() 函数将字符串 “hello” 复制到字符数组 str 中后，实际上只是将 “hello” 的内容复制到了 str 中，并且在最后添加了字符串的终止符 \0。所以，strlen() 函数在计算 str 的长度时，会在遇到终止符 \0 时停止计数。
因此，尽管 str 的长度为 80，但是实际上存储的字符串 “hello” 的长度为 5。所以，程序运行后调用 strlen(str) 函数将返回 5，而不是 80。
24
24．以下程序段运行后屏幕输出为（ C ）
char a[]=”abc\0mis”;
printf(“%d”,srelen(a));
Ａ．５ Ｂ．８ Ｃ．３ Ｄ．４
这个题目都写错了把，str，这个选3，上面解释过了
函数
1
1.关于C语言函数的描述中，正确的是（ B ）
A.函数的定义可以嵌套，但函数的调用不可以嵌套
B.函数的定义不可以嵌套，但函数的调用可以嵌套
C.函数的定义和函数的调用都可以嵌套
D. 函数的定义和函数的调用都不可以嵌套
定义不可以嵌套，但是调用可以
2
2.已知char a；使用scanf（）函数输入一个字符给变量a，不正确的函数调用是（ B ）
A.scanf（“%d”，＆a）; B.scanf（“%lf”，＆a）;
C.scanf（“%c，＆a）; D.scanf（”%u”，＆a）;
%u：用于打印无符号十进制整数。
b是float类型的，不可以。char在c语言中是按照整数类型存储
3
3.putchar（）函数的功能是向终端输出（ B ）
A.多个字符 B.一个字符
C.一个实型变量值 D.一个整型变量表达式
这个记住就好了
扩展一个getchar() 函数的功能是从标准输入（通常是终端）获取一个字符。
4
4、已知int a；使用scanf（）函数输入一个整数给变量a, 正确的函数调用是( B )
A、scanf（“%d”, a）; B、scanf（“%d”,＆a）;
C、scanf(“A”, ＆a ); D、scanf(“%df”, ＆a );
5
5.C语言的函数体由( B )括起来
A.( ) B.{} Ｃ．［］ Ｄ．／* *／
这个就不多说了
6
6.如下fun函数的类型是（ C ）
fun(float x)
{
double y;
int z;
y=x*x;
z=(int)y;
return(z);
}
Ａ．void B.double C.int D.float
最后返回的数据是int。所以就是int类型啦
7
7.设有如下函数定义:
int fun(char *str)
{
char *p;p=str;
if(p!=‘\0’)
p++;
return (p-str);
}
则以下语句执行后的输出结果是( A )
printf(“%d\n”,fun(“student”));
A. 7 B. 8 C. 9 D. 10
你妈妈的，编译都编译不了额额额额。
自己算算吧，大致就是定义了一坨指针，和一个变量。如果这个变量不是\0,那就给指针往后移一位，就是算了下这个字符串的长度。哪有这样算的啊？不是，真可以这样算吗？
8
8.以下程序的屏幕输出为(B)
#include<stdio.h>
void f（int i）
{
int a=2；
a=i++；
printf（“%d”，a）；
}
main（）
{
int a=1 ，c=3；
f（c）；
a=c++;
printf（“%d”，a）；
}
A. 4，3 B. 3，3 C.4，5 D. 3，5
在 f(c) 调用中，传递给 f() 函数的参数是变量 c 的值，即 3。在函数内部，变量 a 被赋值为 2，并且 i++ 表达式的值被赋给 a。这意味着 a 的值将是 i 在自增之前的值，即 3。所以 printf 语句会输出 3。
然后在 a = c++ 语句中，变量 c 的值被赋值给变量 a，即 a 的值变为 3。在赋值完成之后，c 的值自增，变为 4。所以 printf 语句会输出 3。
9
9.若有以下函数定义:
int fun ()
{
static int k=0;
return ++k;
}
以下程序段运行后屏幕输出为( D )
int i;
for (i=1;i＜=5 i++)
fun();
printf(“%d”,fun());
A. 0 B. 1 C. 5 D. 6
分析一下这个函数的作用，定义了一个静态变量k
这里就需要注意静态变量的特性了，静态局部变量是在编译的时候赋初值。即只赋初值一次，不会随函数调用结束后其存储单元消失
然后执行了5+1次的fun函数，最后输出fun函数的返回值，函数里面是先加再输出的，所以选D
10
10.以下程序运行的结果是（ Ａ ）
int fun (int array[4][4])
{
int j;
for(j=0;j＜4;j++)//神说这样会更占用资源，不入++j
printf(“%2d”,array[2][j]);
printf(“\n”);
}
main()
{
int a[4][4]={0,1,2,0,1,0,0,4,2,0,0,5,0,4,5,0};
fun(a);
}
A.2005 B.1004 C.0120 D.0450
fun的函数效果就是，将输入的二维数组，的第3行一次输出，所以就是A
11
11.以下程序运行后屏幕输出为（ D ）
#include〈stdio.h〉
int a=2 ，b=3；
int max（int a，int b）
{
int c；
c=a＞b？a:b；
return（c）；
}
main（）
{
int a=4；
printf（“%d”，max（a，b））；
}
A. 2，3 B. 2 C. 3 D. 4
max函数的作用就是寻找两个数中的最大值，这个考的就是作用域把，肯定是选择4啊，不用说，因为前面的ab是在编译的时候定义的，然后你main函数又重新定义了一次a，肯定使用重新定义的。
12
12.以下程序运行后屏幕输出为( B )
#include<stdio.h>
int f(int x,int y)
{
return(x+y);
}
main()
{
int a=2,b=3,c;
c=f(a,b);
printf(“%d+%d=%d\n”,a,b,c);
}
A.0 B.2+3=5 C.2+3=0 D.3+2=5
输出的是一个表达式，abc的值，a的值就是2，b是3，c是两个相加，就是5.所以选B
13
13、下面程序的输出结果是（ D ）
#include<stdio.h>
int global=100;
fun ( )
{
int global=5;
return ++global;
}
void main( )
{
printf (“% d\n”, fun( ) )
}
A、100 B、101 C、5 D、6
然后这里又是考作用域的问题啊，定义了一个全局的global变量和一个fun内部的局部变量。我觉得函数内部肯定使用的就是函数内部的局部变量咯
我的博客也写了在文件的某处引用重名变量时，所引用的变量就是作用域较小的那一个变量。
预处理命令
1
1.若有定义：#define PI 3，则表达式PI*2*2的值为（ A ）
A.12 B.4
C.3 D.不确定
3*4就是十二
2
2.设有如下定义typedef int *INTEGER；INTEGER P，*q；则（ C ）是正确的表述
A.P是int型变量 B .q是基类型为int的指针变量
C.P是基类型为int的指针变量 D.程序中可用INTEGER代替int类型名。
在这里，INTEGER 被定义为 int *，即指向整型的指针类型。
根据定义，P 是 INTEGER 类型的变量，即 int * 类型的变量。因此，P 是基类型为 int 的指针变量。
同样，q 也是 INTEGER 类型的变量，即 int * 类型的指针变量。因此，q 也是基类型为 int 的指针变量。
这道题有意思哈，我第一次看也选错了。需要着重复习！！
3
3、以下叙述中，正确的是（ A ）
A、宏展开不占用运行时间，只占用编译时间
B、预编译处理命令行必须以分号结束
C、一个源程序只能有一个预编译处理命令行
D、使用带参数的宏定义时，应该说明每个参数的数据类型
A. 宏展开是在编译时期进行的，它会将宏定义的部分替换为相应的代码。因此，宏展开不会在运行时产生额外的开销，它只在编译期起作用，所以只会占用编译时间。
B. 预编译处理命令行以 # 字符开头，而不是以分号结束。
C. 一个源程序可以有多个预编译处理命令行，以插入包含文件、定义宏等。
D. 在使用带参数的宏定义时，不需要明确指定每个参数的数据类型。宏展开只是进行简单的文本替换，不像函数有参数的类型检查。
4
4、以下的叙述中不正确的是（ C ）
A、宏展开不占用运行时间，只占用编译时间
B、宏名无类型
C、宏名必须用大写字母表示
D、预处理命令行都必须以#号开始
和上面那道题差不多
A. 宏展开是在编译时期进行的，它会将宏定义的部分替换为相应的代码。因此，宏展开不会在运行时产生额外的开销，它只在编译期起作用，所以只会占用编译时间。
B. 宏名没有类型，它只是一个标识符，用于标识宏定义的部分。
C. 宏名没有强制要求使用大写字母表示。宏名的命名规范与其他标识符一样，通常建议使用大写字母加下划线的形式，以提高可读性和与其他标识符的区分度。但并非必须使用大写字母。
D. 预处理命令行都必须以 # 号开始，以标识预处理命令，对于大多数预处理命令，确实需要以 # 号开始。例如，宏定义、包含文件等。
5
5．以下叙述中，正确的是（ B ）
Ａ．＂#define PRICE＝３０＂定义了３０等价的符号常量PRICE
Ｂ．预编译处理命令行都必须以＂#＂开头
Ｃ．宏名只能是含大写字母和数字字符
Ｄ．在程序的一行上可以书写几个有效的宏定义
A. #define PRICE=30 定义的是 PRICE=30 这个宏，而不是 30 这个符号常量。在宏展开时，会将 PRICE 替换为 30，而不是直接将 30 视为符号常量。
B. 预处理处理命令行都必须以 # 开头，以标识预处理命令。预处理命令包括宏定义 #define、条件编译 #if、#ifdef、包含文件 #include 等。
C. 宏名可以包含大写字母、小写字母、数字和下划线。并无限制只能使用大写字母和数字字符。
D. 在一行上可以书写多个有效的宏定义，每个宏定义之间用分号或者换行符分隔。
这道题，我们只能当做D是错误的了，实际上D选项我写过程序，正常运行了的。
6
6.下面程序的输出结果是（C）
#include〈stdio.h〉
#define ONE 1
#define TWO ONE+1
#define THREE TWO+1
void main （）
{
printf（“%d\n”,THREE-ONE）;
}
A.产生错误, B. 1 C. 2 D. 3
3-1等于2嘛
根据宏定义展开的原理，宏的展开是简单的文本替换。在给定的代码中：
首先，宏 ONE 被定义为 1，所以 TWO 直接进行宏展开就是 ONE+1，即 1+1。
然后，宏 THREE 直接进行宏展开就是 TWO+1，即 (ONE+1)+1，这里 ONE 视为字面值常量。
最后，在 printf() 函数中，THREE-ONE 进行宏展开就是 ((ONE+1)+1)-ONE，即 (1+1+1)-1，结果为 2。
7
7.以下程序执行时,输入1 2 3 4 5<回车>输出为( A )
#include<stdio.h>
#define N 5
void main()
{
int a[N];
int *p=a;
while(p<a+N)
scanf(“%d”,p++);
while(p>a)
prinf(“%s”,*(--p));
}
A.5 4 3 2 1 B.1 2 3 4 5 C.2 3 4 5 1 D.4 3 2 1 5
第一个while就是比较两个是指针的大小，因为指针p是指向的a数组的首地址，一直加到a+N停止，也就是说比a数组最大的还多了个地址，正好让p停留在a数组的最后一个元素的位置。
所以第一个while就是给a数组依次赋值，后面的while就是让while从最后开始输出，（这些b题放在编译器都要报错的，也不知道是谁写的。）
所以就是倒着输出54321
8
8.若有以下定义
#define MOD(x,y) x%y
则执行以下程序段后,z的值是( D )
int z,a=15,b=100;
z=MOD(b,a);
A.100, B.15 C.11 D.10
根据给定的宏定义 #define MOD(x,y) x%y，宏展开后 z=MOD(b,a) 变成 z=b%a。
所以，z 的值是 100 % 15，结果为 10。因此，选项 D 正确。
9
9、下面程序的输出结果是（ A ）
#include<stdio.h>
#define SQR(x) (x*x)
void main()
{
int a,b=3;
a=SQR(b+2);
printf(“\n%d”,a);
}
A．11 B．25 C．不定值 D．产生错误
这道题需要注意了！！！！！！，这个define只是最基础的文本替换，
所以我们这个替换之后是这样的
void main()
{
int a,b=3;
a=(b+2*b+2);
printf(“\n%d”,a);
}
自然输出的就是11了！！！！
指针
1
1.若函数fun的函数头为：int fun（int i，int j）且函数指针变量P定义如下：int （*P）（int i，int j）；则要使指针P指向函数fun的赋值语句是（ B ）
A. P=*fun B. P=fun；
C. P=fun（i，j） D. P=＆fun
int (*P)(int i, int j) 表示 P 是一个指向具有两个 int 类型参数和一个 int 类型返回值的函数的指针。
这个确实比较难理解哈，但是答案就是选B，这句解析好好看一下。
2
2.设有以下语句，则（ D ）是对数组元素的不正确引用，其中.int a[10]={0,1,2,3,4,5,6,7,8,9},*p=a
A．a[p-a] B．*(&a[i])
C．p[i] D．*(*(a+i))
a啊啊啊啊啊啊我要疯掉了，首先C肯定是对的
a 是一个数组名，代表数组的首地址，因此 a 的值为 &a[0]。
p 是一个指针变量，指向数组 a 的首地址，即 &a[0]。
然后第一个是p-a是地址差值，而p就是指向的a的第一个元素， 所以相减是0，然后就相当于是a[0]
第二个呢，&a[i]指的是a的i的元素的地址，而*又是指向这个地址，所以是正确的
最后一个，a+i，指向他一个就够了。
*(*(a+i))：这是一个不正确的引用。在这种语法中，我们尝试将数组 a 视为一个二维数组，并通过 *(*(a+i)) 来访问其中的元素。但是，事实上，数组 a 是一个一维数组，这样的引用是不正确的。
3
3、在16位编译系统上，若有定义int a [ ]={10，20，30}，*p=＆a；当执行p++；后下列叙述错误的是（ A ）
A、p向高地址移了一个字节
B、p与a+1等价
C、语句printf(“%d”, p)；输出20
D、p指向数组元素a[1]
后面三个我都能理解，这个a是什么意思？
A. p 向高地址移了一个字节：这个叙述是错误的。在16位编译系统中，指针的大小是2个字节（16位），而不是1个字节。因此，执行 p++ 操作后，p 移动的是2个字节的大小，而不是1个字节。所以，叙述 A 是错误的。
酱紫啊。。
在C语言中，指针的大小是由编译系统的位数决定的。一般而言，32位编译系统中指针的大小是4个字节（32位），64位编译系统中指针的大小是8个字节（64位）。
4
4、以下程序段运行后*（++p）的值为（C）
char a[6]=“work”;
char *p;
p=a;
A、‘w’ B、存放‘w’的地址 C、‘O’ D、存放的‘O’地址
这个就不说了把，++p是指向那个地方的地址，*就引用了他。
5
5.在16位编译系统上,若有定义int a[]={10,20,30},*p=&a;当执行p++;后下列叙述错误的是( A )
A.p向高地址移了一个字节 B.p与a+1等价
C.语句printf(“%d”,*p);输出20; D.p指向数组元素a[1]
这个不收了好吧不就是上面那个题吗
6
6.以下程序运行后*（P+3）的值为（ A ）
char a[]=“good”； char *P；P=a；
A.‘d’ B.‘\0’
C.存放‘d’的地址 D.‘0’
一样的啊*引用了d的地址，所以输出d
7
7.以下程序运行后x的值为(D)
int a[9]={1,2,3,4,5,6,7,8,9};
int *p,*q;
int i,x;
p=＆a[0];
q=＆a[8];
for (i=O;i＜3;i++)
if(*(p+i)==*(q-i) )
x=*(p+i)*2;
A. 2 B. 4
C. 6 D.不确定
for循环三次，然后并没有找到一样的数，所以x没有被赋值。
- 当
i = 0时，*(p+i) = *(p+0) = *p = 1，*(q-i) = *(q-0) = *q = 9。因此，条件不满足，进入下一次迭代。 - 当
i = 1时，*(p+i) = *(p+1) = *(p+1) = 2，*(q-i) = *(q-1) = *(q-1) = 8。因此，条件不满足，进入下一次迭代。 - 当
i = 2时，*(p+i) = *(p+2) = *(p+2) = 3，*(q-i) = *(q-2) = *(q-2) = 7。因此，条件不满足，循环结束。
8
8.以下程序运行段运行后x的值为( D )
int a[]={1,2,3,4,5,6,7,8};
int i,x *p;
x=1;
p=＆a[2];
for(i=0,i＜3,i++)
x*=(p+i);
A. 不确定 B. 24 C. 120 D. 60
x为1，p指向a的第三个元素，for循环三次。
x乘以p+0的元素，第一次是3，第二次是，12，第三次是，60
值得注意的是，代码是错的哈，应该是x *= *(p + i);
9
10．执行以下程序段的输出结果是（ B ）
int a=10,*p=&a;
printf(“%d”,++*p);
A．１０ Ｂ．１１
Ｃ．变量a的地址 Ｄ．变量a的地址加１
*p的值是10哈，加一个就是11
根据运算符优先级，前缀递增运算符 ++ 具有比间接解引用运算符 * 更高的优先级，因此 ++*p 将先递增 *p 所指向的值，然后取得递增后的值。
结构体与共用体
1
1.设有以下定义语句：
struct student{
int num；
char name[10]；
float score;
}wang，zhang；的变量wang所占的内存字节是（ B ）
A.14 B.16. C.18 D.9
关于结构体：
1.结构体变量的首地址能够被其最宽基本类型成员的大小所整除。
2.结构体成员相对于结构体变量的首地址的偏移量（结构体变量的首地址编号和结构体成员的地址编号他们之间所差的字节数）都是其成员大小的整数倍
3.结构体的总大小为结构最宽基本类型成员的整数倍
这里最宽的基本类型是float，4个字节，所以一定会被4整除
2
2.设有以下定义语句:
struct student{
int num ;
char name[10];
float score;}wang,zhang;
则不正确的叙述是( C )
A.struct 是结构体类型的关键字 B.zhang是结构体变量名
C.wang是结构体类型名 D.num,name,score都是结构体类型student的成员名
结构体类型名为 student，而 wang 和 zhang 是具体的结构体变量名。
3
3.若struct teacher{
int num；
char name[10]；
char sex；
int age；
float score；}teacher1；
则变量teacher1所占用的内存字节是（ C ）
A.5 B.14 C.19. D.20
1、找到结构体中最大的成员变量所占的字节数
2、结构体中成员变量的起始地址为该成员变量大小的整数倍（一般情况下我们认为第一个成员变量的起始地址为0）
3、结构体变量的总大小必须要是结构体中最大变量字节的整数倍（不足补齐）
答案是24个字节，我运行了程序的，分析一下。int，就是四个字节，0+4，1可以从4开始存，所以4+11=15，int是4，需要从16开始存，所以16+4，float是4，可以从20开始，所以是24.
4
4.、假定已有如下变量说明和枚举定义：
char ch;
int j,k;
enum day{sum,mon,tue,wed,thu,fri,sat};
int a[sat];
判定下列语句是否符合语法规则，结果是（ C ）
char a; /*语句1*/
j+k=j; /*语句2*/
if（a[mon]>0） j++; /*语句3*/
A．语句2错误，其它正确 B．语句1正确，其它错误
C．语句3正确，其它错误 D．语句错误，其它正确
enum A {a1,a2,a3,a4};//c语言在定义的时候会根据这些元素的顺序定义一个默认值，分别为0.1.。。。。
enum B { b1=3, b2, b3, b4=5 };//定义枚举类型的时候可以为枚举元素指定一个值，为指定值的元素将是前一个元素+1
int main(void) {
enum A w = a2;
enum B w2 = b2;
printf("%d,%d,%d\n", a2, a3, b2);//输出124
return 0;
}
这个是博客中的一些总结。看了就会明白了。
5
5、以下C语言共用体类型数据的描述中，不正确的是（ D ）
A、共用体变量占的内存大小等于所需内在最大的成员所占的内存
B、共用体类型可以出现在结构体类型定义中
C、在定义共用体变量的同时允许对另一个成员的值进行初始化
D、同一共用体中各成员的首地址不相同
值得注意的是，共用体的所有成员所使用的内存的开头地址的值都是一样的，所以当我们对其中一个成员赋值时，会把这个变量中原油数据诶给覆盖掉
在共用体中，所有成员共享同一块内存空间。共用体变量的内存大小取决于最大的成员所需的内存大小。共用体类型可以出现在结构体类型定义中，可以在定义共用体变量的同时对另一个成员进行初始化。
然而，共用体的不同成员可能具有不同的类型和长度，但它们共享相同的起始地址，因此同一共用体中各成员的首地址是相同的。
6
6、若有以下类型说明，叙述正确的是（ C ）
typedef sturct{
int num;
char *name;
int score;
} STU, *PSTU
A、STU 是变量名 B、PSTU是变量名
C、PSTU是指向结构体类型STU的指针类型名
D、类型说明语句有错误
这个简单啊
typedef int count这个时候count就代表的是int类型的数据。count a = 3;这个a就是个整型数据。
STU是一个结构体类型名，包含了int num、char *name和int score这三个成员。使用STU可以声明结构体类型的变量，比如STU stu1;。PSTU是一个指针类型名，它是指向STU类型的指针。也就是说，PSTU可以用来声明指向结构体的指针变量，比如PSTU pStu;。
7
7、设有如下定义语句：
union u-type{
int i;
double x;
float f;
};
struct str-type{
char str[100];
union u_type u[2];
};
则语句“printf(“%d”, sizeof(struct str-type) );”的输出结果是（ B ）
A、100 B、116
C、120 D、200
8
下列对结构体类型变量定义不正确的是（ C ）。
A.struct teacher{int num; int age;}teach1;B.struct {int num; int age;}teach1,teach2;C.struct {int num; int age;}teacher; struct teacher teach1;D.struct teacher {int num; int age;}; struct teacher teach1;
c不用看都晓得错了
9
9．若有定义
struct node{
int date;
struct node *next;
}
函数：
void fun(struct node *head)
{
struct node *p=head;
while(p)
{
struct node *q=p->next;
free(p);
p=q;
}
}
则该函数的功能是（ A ）
A. 删除整个单向链表 B. 删除单向链表中的一个结点
C．显示单向链表中的所有数据 D. 创建单向链表
挨个free元素，所以是删除整个单向链表。
10
对枚举类型进行定义，不正确的是（ ）。
A. enum b{1, 2, 3};
B. enum a{A, B, C};
C. enum c{D=3, E, F};
D. enum d{X=0, Y=5, Z=9};
A 错
枚举类型列表中的都是标识符。
还记得标识符的命名要求吗？ 不能以数字开头
几把这些题好多都是错的，还要我一个一个搜索，真该死啊这个学长，题给我都不检查一下，纯骗子，等我入学了😋再来慢慢说他好吧，别被逮着内网有漏洞哈
11
11.下面程序的输出结果为(C)
#include <stdio.h>
int main() {
enum Weekday { sum = 7, mon = 1, tue, thu, fri, sat };
enum Weekday day = sat;
printf("%d\n", day);
return 0;
}
A.7 B.6 C.5 D.4
这个是依次定义的，所以输出5，12345.
12
12.以下程序的运行结果（D）
#include<stdio.h>
union utype{
int i;
float f
}U[2];
void main()
{
printf(“sizeof(u):%d\n”,sizeof(u)) ;
}
A. 2 B. 4 C.6 D. 8
union 是一种特殊的数据类型，在内存中它所有的成员共用同一块内存空间。根据内存对齐的规则，一个 union 的大小等于其包含的成员中占用内存最大的那个成员的大小。在这个程序中，union u 包含有两个成员，一个是 int 类型的 i，一个是 float 类型的 f。sizeof(U) 的结果就是 union u 的大小，根据最大成员的大小为 4，因此程序输出的结果是 8。
13
题目要求是保留其他节点，所以我们要先把p之后的节点位置传输给p之前的pnext，也就是p的next赋值给head的next，然后就可以直接删除p了。所以选a
14
14.若有定义
struct node{
int data;
struct node *next;
};
及函数： void fun(struct node *head)
{
struct node *p=head;
while(p)
{
printf(“%d”,p->data);
p=p->next;
break;
}
}
则函数 fun（ ）的功能是（ C ）
A. 删除单向链表 B. 显示单向链表中的所有数据
C. 显示单向链表中的第一个数据 D. 创建单向链表
由于while最后有个break，所以本来是显示所有数据的函数，变成了只展示第一个数据的函数，
15
这个也不多说了，就是计算节点个数
16
链表的第二个节点就是，head.next指向的节点。插入进去，需要修改head.next和p.next。p.next改成原来的第二个节点，head.next改成现在的节点。
所以选c。
后面还有个题库我就不总结了，也是单选题的，判断题和其他大题或许会总结一下？另外一个单选题的我自己过一遍就好了。
转载请注明来源，欢迎对文章中的引用来源进行考证，欢迎指出任何有错误或不够清晰的表达。后续可能会有评论区，不过也可以在github联系我。