关于概念的问题不做解析，都是死东西，也解析不了
题型
- 选择题（94题）
- 填空题（43题）
- 读程序题（30题）
- 程序填空（17题）
- 答案仅供参考，部分答案不是唯一的
- 编程题（6题）
- 22级考的是第3题
选择题（94题）
1 、以下关于源程序与目标程序的关系，不正确的是 () 。 A 、用机器语言编写的源程序就是目标程序 B 、用汇编语言编写的源程序需要经过汇编程序汇编为目标程序 C 、用 C 语言编写的源程序需要经过编译程序编译为目标程序 D 、C 语言与 Pascal 等其他高级语言的编译器是完全一样的。 答案：D
2 、以下叙述不正确的是 ()A 、一个 C 源程序可由一个或多个函数组成 B 、一个 C 源程序必须包含一个 main 函数 C 、C 程序的基本组成单位是函数 D 、在 C 程序中， 自定义函数的定义需要在主函数 main 体内定义 答案：D 解析：这是一个算“1~100的和”的程序，可以看到，自定义函数sum的定义没有在main里。 #include int sum(); int main() {int S = sum();printf("1~100的和为：%d",S); return 0; } int sum() { int a = 1, sum = 0;for ( a=1;a <= 100; a++){ sum += a; }return sum; }
3 、“程序存储思想”的提出者是 () 。 A 、Dennis M. Ritchie B 、Alan Turing C 、John Von NeumannD 、Ken Thompson 答案：C`
4 、计算机直接能识别的是 () 的代码。 A 、二进制 B 、八进制C 、十进制 D 、十六进制 答案：A
5 、计算机存储的都是二进制信息，信息存储的最小单位是 () 。 A 、字节 (byte ) B 、二进制位 (bit) C 、字 (word)D 、双字 答案：B
6 、若计算机有 32 根地址总线，则其存储器的最大存储容量可达 () 。 A 、32MBB 、32GBC 、4GBD 、8GB 答案：C 解析：存储个数=2^地址线个数 1根地址总线是2B，32根就是：2^32=(2^10)^3 * 4 =4 * (1024B)^3 =4 * 1024MB =4G
7 、下列数据表达的数值与十进制77 不相等的是 () 。A 、0x4DB 、0x4BC 、0115D 、1001101 答案：B 解析：A:这是16进制，0x4D=4*16+13=77 B:这是16进制，0x4B=4*16+11=75 C:这是8进制，0115=1*8^2+1*8+5=77 D:这是2进制，1001101=1*2^6+1*2^3+1*2^2+1=77
8 、以下选项中不属于字符常量的是 () 。 A 、/C/B 、”C”C 、/\x0C/D 、/\072/ 答案：B 解析：“C”用的是双引号，是字符串
9 、在 C 语言中，不同数据类型占用内存的字节长度是 () 。 A 、相同的B 、由用户自己定义的C 、任意的D 、与编译环境有关的答案：D
10 、C 语言中，“\x5d ”在内存中占用的字节数是 () 。 A 、2B 、5C 、4D 、 1 答案：A 解析：用" "括起来的说明它是一个字符串，任何一个合法字符串都是以'\0'结尾的， 第一个字节是"\x5d"的ASCII码字符，第二个字节是字符串结束符'\0'， '\0'是系统自动加上去的。
11、C 语言 short 型数据占 2 个字节，则 unsigned short 型数据的取值范围是 () 。 A 、2~255B 、0~65535C 、-256~255D 、-32768~32767 答案：B
12 、下列哪个选项属于 C 语言中的合法字符串常量 () 。 A 、how are youB 、”china”C 、/hello/D 、$abc$ 答案：B 解析：”china”用的是双引号，是字符串
13 、以下哪一个可以作为正确的变量名 ( ) 。 A 、3*X B 、 filename C 、for D 、$X 答案：B 解析：1.一个变量名称可以由数字、字母、下划线、美元符号($) 组成 2.严格区分大小写 3.不能由数字开头,不要使用中文汉字命名 4.不能是保留字或者关键字 5.不能有空格
14 、有如下输入语句：scanf(“x=%d,y=%d”,&x,&y);为使变量 x 的值为 10 ，y 的值为 20， 从键盘输入数据的正确形式是 () 。 A 、10 20 B 、10 ，20 C 、x= 10 ，y=20D 、x= 10 y=20答案：C 解析：按照scanf中" "内定义的格式输入
15 、如有下列程序，输入数据：12345 678后，程序输出的结果是 () 。 #include int main( ) { int x; double y; scanf(“%3d%f”,&x,&y); printf(“%d,%f\n ”,x,y); return 0; } A 、12345 ，678.000000B 、123 ，45.000000 C 、123 ，不确定的随机数D 、345 ，678.000000 答案：B 解析："%3d"表示以3位的固定宽度输出整型数。不足3位，在前面补空格； 超过3位，按实际位数输出 "%f"表示单精度浮点型，即float,有效位数为7位，小数点后6位 补充："%lf"表示双精度浮点型，即double,有效位数为16位，小数点后15位。
16 、下列关于外部变量的说法，正确的是 ( ) 。 A 、外部变量是在函数外定义的变量，其作用域是整个程序 B 、全局外部变量可以用于多个模块，但需用 extern 重新在各模块中再定义一次C 、全局外部变量可以用于多个模块，extern 只是声明而不是重新定义 D 、静态外部变量只能作用于本模块，因此它没有什么实用价值 答案：C
17 、下列 4 组数据类型中，C 语言允许的一组是 () 。 A 、整型、实型、逻辑型、双精度型 B 、整型、实型、字符型、空类型 C 、整型、双精度型、集合型、指针类型 D 、整型、实型、复数型、结构体类型 答案：B
18 、下列哪一个是合法的实型常量 ( ) 。 A 、8E3. 1 B 、E5C 、234. D 、234 答案：C 解析：实型常量有两种形式： 1、小数形式：小数形式是由数字和小数点组成的一种实数表示形式，例如0.123、.123、123.、0.0等。小数形式表示的实型常量必须要有小数点。2、指数形式：这种形式类似数学中的指数形式。在数学中，一个可以用幂的形式来表示，如2.3026可以表示为0.23026×10^1。在C语言中，则以“e”或“E”后跟一个整数来表示以“10”为底数的幂数， 2.3026可以表示为0.23026E1。字母e或E之前必须有数字，且e或E后面的指数必须为整数，如e3、5e3.6、.e、e等都是非法指数形式。在字母e或E的前后以及数字之间不得插入空格。
19 、设有说明；char z ；int w ；float y；double x ；则表达式 w-x ＋z-y 值的数据 类型为 ____。 A 、floatB 、charC 、intD 、double 答案：D 解析：两个不同类型的运算，要转化成同类型的，转换从低到高 char-->float-->short-->int-->double
20 、下列运算符中，优先级最高的是（） A 、()B 、* C 、==D 、+= 答案：A
21 、设 a 、b 、c 都是 int 型变量，且 a=3,b=4,c=5 ，则下列表达式中值为 0 的是 ( ) 。A 、‘a’&&‘b ’B 、a<b C 、a||b+c&&b-c D 、!(a<b&&!c||1)答案：D解析：首先要了解一点，c语言中，错误是0，正确是非0。逻辑与（&&）要求均为正确（非0）才是正确（非0），否则为错误（0）逻辑或（||）要求有一个正确（非0）即为正确（非0）这东西出题的话一般比较乱，如果没懂一定要耐心理解A：我也没看懂这是的啥，这打了个单引号，不知道是不是想表达这是个字符的意思，反正是错的B:"a<b"是正确的，值为非0C:"a||b+c"是两个非0量通过逻辑或（||）链接，是非0. 然后"非0"与"b-c"这个非0量通过逻辑与（&&）链接，也是非0D："a<b"为非0； "c"是非0，则"!c"是非"非0"，即"0"。 "非0"与"0"通过逻辑与（&&）链接，则为"0"。 "0"与"1"（非0）通过逻辑或（||）链接，则为“非0”， 之后由于"!"使得"非0"变为非"非0"，即"0"
22 、表达式(int)((double)7/2)-7%2 的值是 ( ) 。 A 、1B 、1.0C 、2D 、2.0 答案：C 解析：(double)7/2=3.5 (int)((double)7/2)-7%2=(int)3.5-1 =3-1 =2
23 、若 d 是 double 型变量，表达式”d=1,d=5,d++”的值是()。 A 、1.0B 、2.0C 、5.0D 、6.0 答案：C 解析：逗号表达式从左到右执行，取最后一个表达式的值， d++是先用后自增，在表达式结束前不起作用，所以d仍为5
24 、以下程序的运行结果是()void main() { int k=4,a=3,b=2,c= 1; printf(“\n%d\n”,k
25 、表达式 !(m>0&&n>0)等价于() A 、!(m>0)||!(n>0)B 、!m>0||!n>0C 、!m>0&&!n>0D 、!(m>0)&&!(n>0) 答案：A 解析：!(m>0&&n>0)等价于!(m>0)||!(n>0)
26 、语句 while(!E) ；中的表达式！E 等价于（）A 、E= =0 B 、E！= 1 C 、E！=0 D 、E= = 1 答案：A 解析：c语言中除0以外的为非0 E!=0，所以!E=0
27 、关于 switch 语句，下列说法中不正确的是 () 。 A 、case 语句必须以 break 结束B 、default 分支可以没有 C 、switch 后面的表达式可以是整型或字符型 D 、case 后面的常量值必须唯一答案：A
28 、若要求在 if 后一对圆括号中表示 a 不等于 0 的关系,则能正确表示这一关系的表达式为() A 、a0 B 、!a C 、a=0D 、a 答案：D 解析：a本来就是非0，不需要其他修饰
29 、以下程序的输出结果是（）#includevoid main(){int x= 10,y= 10;printf("%d %d\n",x--,--y);} A 、 10 10B 、9 9 C 、 9 10 D 、10 9 答案：D 解析： "x--"是先用后自减，在表达式结束前不起作用，所以x仍为10"--y"是先自减后用，当场就起作用，所以y为10-1=9
30 、设有如下定义:int x= 10,y=3,z; 则语句printf("%d\n",z=(x%y,x/y)); 的输出结果是（） A 、1 B 、0C 、4 D 、3 答案：D 解析：z=(x%y,x/y)等价于z=(1,3) 逗号运算符从左往右，所以z=3
31 、为表示关系 x ≥y≥z,应使用 C 语言表达式（） A 、(x>=y)&&(y>=z)B 、(x>=y)AND(y>=z)C 、(x>=y>=z) D 、(x>=y) & (y>=z) 答案：A 解析："x ≥y≥z"的意思是"x ≥y"并且"y≥z"，c语言没有"x>=y>=z"这种写法
32 、C 语言中非空的基本数据类型包括（） A 、整型,实型,逻辑型 B 、整型,实型,字符型 C 、整型,字符型,逻辑型 D 、整型,实型,逻辑型,字符型 答案：B
33 、若 x 和 y 都是 int 型变量,x= 100,y=200,且有下面的程序片段:printf("%d",(x,y)); 上面程序片段的输出结果是（） A 、200B 、100 C 、100 200D 、输出格式符不够,输出不确定的值 答案：A 解析：逗号运算符，从左向右，%d先是代表x，之后x又被y顶替
34 、阅读下面的程序 #includevoid main(){ char ch; scanf("%3c",&ch); printf("%c",ch);}如果从键盘上输入abc则程序的运行结果是（） A、 aB、 b C、 cD、程序语法出错 答案：A 解析："char ch"输入的是字符，输入三个字符，输出一个字符，"abc"输出就是"a"
35 、阅读下面的程序 #include void main(){ int i,j; i=010; j=9; printf("%d,%d",i-j,i+j);}则程序的运行结果是（） A 、1, 19B 、- 1, 19 C 、1, 17D 、- 1, 17 答案：D 解析："i=010"是一个八进制的数，所以i=1*8^1+0=8 所以i-j=8-9=-1；i+j=8+9=17
36 、阅读下面的程序 #include void main(){ int i,j,m,n; i=8;j=10; m=++i; n=j++; printf("%d,%d,%d,%d",i,j,m,n);} 程序的运行结果是（） A 、8, 10,8, 10 B 、9, 11,8, 10 C 、9, 11,9, 10 D 、9, 10,9, 11 答案：C 解析：先定义"i=8;j=10;"，之后"m=++i;"，由于自增(++)在前，先加后用，所以m=8+1=9，同时i=8+1=9 然后"n=j++;"，由于自增(++)在后，先用后加，所以n=10，同时j=10+1=11
37 、若已定义 int a,则表达式 a= 10,a+ 10,a++的值是（） A 、20B 、10C 、21D 、11 答案：B 解析：逗号运算符从左向右看，首先"a= 10"，定义a 的值 然后"a+ 10"虽然值为10+10=20，但是a值本身不变 最后"a++"由于自增(++)在后，先用后加，"a++"的值仍然是10，这行代码结束，a的值才为11
38 、阅读下面的程序 #include void main(){ int i,j; scanf("%3d%2d",&i,&j); printf("i=%d,j=%d\n",i,j);} 如果从键盘上输入 1234567,则程序的运行结果是（） A 、i=123,j=4567B 、i=1234,j=567 C 、i=1,j=2 D 、i=123,j=45 答案：D 解析：i取3位，j取2位，输入1234567，则i=123，j=45
39 、下面程序的输出结果是（）#includevoid main(){ int a=-1, b=4, k; k=(++a<=0)&&(b--<=0); printf("%d,%d,%d\n",k,a,b);} A 、1, 1,2B 、1,0,3C 、0, 1,2D 、0,0,3 答案：D 解析："++a<=0"，a先加后用，是对的；"b--<=0"，b先用后减，是错的，以逻辑与(&&)链接，所以"k=0" 同时，代码k=(++a<=0)&&(b--<=0);结束前“a=0,b=4”，结束后“a=0,b=3” 所以k=0,a=0,b=3
40 、C语言中规定函数的返回值的类型是由（） A 、return语句中的表达式类型所决定的 B 、调用该函数时的主调用函数类型所决定的 C 、调用该函数时系统临时决定的 D 、在定义该函数时函数首部所指定的函数返回类型所决定的 答案：D
41 、对于 C 语言的函数，下列叙述中正确的是（） A 、函数的定义不能嵌套，但函数调用可以嵌套 B 、函数的定义和调用都不能嵌套 C 、函数的定义可以嵌套，但函数调用不能嵌套 D 、函数的定义和调用都可以嵌套 答案：A
42 、若函数调用时的实参为变量，以下关于函数形参和实参的叙述中正确的是（）A 、函数的实参和其对应的形参共占用同一存储单元 B 、形参只是形式上的存在，不占用具体存储单元 C 、函数的形参和实参分别占用不同的存储单元 D 、同名的实参和形参占用同一存储单元 答案：C
43 、下面关于静态局部变量的描述，不正确的是（） A 、静态局部变量只被初始化一次 B 、静态局部变量作用域为整个程序 C 、静态局部变量生命期为整个程序 D 、静态局部变量作用域为当前函数或语句块 答案：B
44 、若主函数有变量定义：int x= 1; double y=2.3;且有合法的函数调用语句 f (y, x);则下列关于函数 f 的原型声明中一定错误的是（） A 、void f(double, int); B 、int f(int, int); C 、int f(double, double); D 、void f(double, int, int); 答案：D 解析：通过强制类型转换，A、B、C都是可行的， D：多定义一个数，是错的
45 、关于作用域的描述，下列哪一种说法是正确的（） A 、形式参数的作用域一定是它所在的整个函数 B 、全局变量的作用域一定是整个程序 C 、局部变量的作用域一定是整个函数 D 、静态局部变量的作用域不仅限于本函数 答案：A
46 、以下一维数组定义语句中，错误的是（） A 、int a[]={1,2,3,4} ; B 、char a[5]; C 、char str[6]= "test"; D 、int n=5,a[n]; 答案：D 解析：D想表达的应该的定义一个五位的一维数组，正确写法为int a[5];
47 、若有说明：int a[ 10];则对 a数组元素的正确引用是（） A 、a[ 10] B 、a[3.5] C 、a(5) D 、a[10- 10] 答案：D 解析：定义的是一个十位的一维数组，但是引用时要注意，第一位是a[0]，第二位才是a[1] A：引用时a[10]指向的是第11位，越位了，错误 B：第4.5位是啥，没有这个东西，错误 C：数组是中括号，不是小括号，错误 D：a[10-10]，即a[0]，正确
48 、以下不能对二维数组 a 进行正确初始化的语句是（） A 、int a[2][3]={0}; B 、int a[][3]={{1,2}, {0}}; C 、int a[2][3]={{1,2}, {3,4}, {5,6}}; D 、int a[][3]={1,2,3,4,5,6}; 答案：C 解析：二位数组第一个中括号表示列数，第二个表示行数 A：全部定义为"0" B：可以只对部分元素赋值，未赋值的元素自动取"0"值。例如：int a[3][3] = {{1}, {2}, {3}};赋值后各元素的值为：100200300 C：定义是两行三列，赋值时却是三行两列 D：如果对全部元素赋值，那么第一维的长度可以不给出。例如：int a[3][3] = {1, 2, 3, 4, 5, 6, 7, 8, 9};可以写为：int a[][3] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
49 、以下对二维数组 a 定义正确的是（） A 、int a[3][]; B 、float a(3,4); C 、double a[ 1][4]; D 、float a(3)(4); 答案： 解析：A：这个语句试图定义一个拥有3行而列数不固定的二维数组， 但编译器要求多维数组的除最高维度外的每个维度必须为已知量，因此这句话不能通过编译。 行可以省略，但是列不能省略。 int a[][3]合法，但int a[3][]不合法 B：中括号，不是小括号，而且第一维和第二维放在同一个括号里 D：中括号，不是小括号
50 、如下程序执行后输出为（）#includeint main( ){ static int a[3][3]; int i, j; for(i=0;i<3;i++) for(j=0;j<3;j++) a[i][j]=a[j][i]+i*j; printf("%d, %d", a[1][2], a[2][1]); return 0;} A 、2,2B 、2,4 C 、4,2D 、不确定,不确定 答案：B 解析：数组里如果没有数当作"0"这组代码的结果是： 000 014 024
51 、以下程序给数组所有元素输入数据，填入（）能完成该功能。#includeint main ( ){ int array [5], i=0; while (i<5) scanf("%d", __________ ) ; return 0;} A 、&array[i++]B 、&array[i+1] C 、array+iD 、&array[++i] 答案：A 解析：i的初值为0，一维数组array[s]的第一位是array[0]，所以i要先用后增
52 、若有函数原型:double f(int, double); ，主函数中有变量定义：int x= 1; double m= 11.6,n;下列主函数中对f函数的调用错误的是 ( )A 、n=f(x, m+2); B 、printf(“%lf”,f(x+2, 23.4)); C 、f(x,m);D 、m=f(x); 答案：D 解析：D：少一个数，正确写法同A
53 、表达式____ 的值不是 1。 A 、4=1 C 、!EOFD 、!NULL 答案：C 解析：A：4=1，是对的，所以值为1 C：EOF指文件结束，逻辑不通 D：NULL是一个未知值，同时NULL 不等于0，也不是’'(空字符串)，所以!NULL的值为1
54 、有如下函数调用语句func(rec1,rec2+rec3,(rec4, rec5));该函数调用语句中,含有的实参个数是 ( ) 。 A 、3 B 、4C 、5 D 、有语法错误 答案：A 解析："(rec4, rec5)"是逗号运算符，取最后的为值 三个实参分别为：rec1 rec2+rec3 (rec4, rec5)
55 、以下有关函数的形参和实参的说法中正确的是（） A 、实参和与其对应的形参各占用一个字节存储单元 B 、只有当实参和与其对应的形参同名时才占用一个存储单元 C 、形参是虚拟的，不占用存储单元 D 、实参和与其对应的形参各占用独立的存储单元 答案：D 解析：程序运行状态下，调用到形参时，会给形参独立的储存单位。若未运行，形参则不会占用存储单元。
56 、能正确表示“当 x 取值在[5，99]和[130 ，180]范围内为真，否则为假”的表达式是（） A 、(x>=5)&&(x=130)&&(x=5)&&(x=130)&&(x=5)||(x=130)||(x=5)&&(x=130)||(x<=180) 答案：B 解析："当 x 取值在[5，99]和[130 ，180]范围内"意思是：x的值"大于等于5，小于等于99"或"大于等于130，小于等于180"所以B选项是对的
57 、以下错误的定义语句是（）。 A 、int x[][3]={{0}, { 1}, { 1,2,3}};B 、 int x[4][3]={{1,2,3}, { 1,2,3}, { 1,2,3}, { 1,2,3}}; C 、int x[][3]={1,2,3,4};D 、int x[4][]= {{1,2,3}, { 1,2,3}, { 1,2,3}, { 1,2,3}}; 答案：D 解析：D：编译器要求多维数组的除最高维度外的每个维度必须为已知量，因此这句话不能通过编译。行可以省略，但是列不能省略如果对全部元素赋值，那么第一维的长度可以不给出
58 、设有语句 int a[2][3] ，下面哪一种不能表示元素 a[i][j]（） A 、*(a[i]+j)B 、*(*(a+i)+j) C 、*(a+i*3+j) D 、*(*a+i*3+j) 答案：C 解析：正确表达方式为A、B、D，可以参考这些选项来理解二维数组不同的表达方式 可以把这几种表达记一下
59 、假设已定义 char a[10], *p;下面的赋值语句中，正确的是 ( ) 。 A 、p=a;B 、a="abcdef"; C 、*p="abcdef";D 、p=*a答案：A 解析：a表示数组的首地址 p是一个指针变量，可以将数组的首地址赋值给p, 所以p=a;是正确的
60 、下面判断正确的是________。 A 、char *a="programming";等价于 char *a;*a="programming"; B 、char str[10]={"programming"};等价于 char str[10]; str[]={"programming"};C 、char *s="programming";等价于 char *s; s="programming"; D 、char *s="programming";等价于 char s[10];*s="programming"; 答案：B 解析：这我也不知道咋讲，考的是一维数组的赋值，算是一个c语言写法的问题
61 、判断字符串 str1 是否大于字符串 str2 ，应当使用（） A 、if(str1>str2) B 、if(str1>=str2) C 、if(strcpy(str2,str1)>0) D 、if(stcmp(str1,str2)>0) 答案：D 解析：B：strcpy(字符数组1，字符串2) strcpy是“字符串复制函数”。作用是：将字符串2复制到字符数组1中去。 D：strcmp() 会根据 ASCII 编码依次比较 str1 和 str2 的每一个字符，直到出现不到的字符，或者到达字符串末尾（遇见\0）。返回值：如果返回值 0，则表示 str2 小于 str1。如果返回值 = 0，则表示 str1 等于 str2。
62 、设 p1和 p2 是指向同一个字符串的指针变量，c 为字符变量，则以下不能正确执行赋值语句的是（） A 、c=*p1+*p2B 、p2=c-5 C 、p1=p2D 、c=*p1*(*p2) 答案：B 解析：A：求指针p1和p2指向的地址单元中存放的数据相加的值 B：c是字符变量 p2是指针变量，指针变量只能付地址，改为p2=&c成立 C：p1=p2是给一个变量赋值,使得p1原来的值被覆盖 D：求指针p1和p2指向的地址单元中存放的数据相乘的值
63 、设变量定义为 int x, *p=&x,则&*p 相当于（） A. &x B. *p C. xD. *&x 答案：A 解析：*p=&x 是内存（位置：地址p）的内容= x的内存地址 可以尝试这样理解：因为 p = &x *p = *&x &*p = &*&x 一个*和一个&抵消了,因此&*&x = &x
64 、若有语句int *point,i=4; 和point=&i，下面均代表地址的是 () A. i, point,*&i B.&*i,&i,*point C. *&point,*point,&iD. &i ,&*point,point 答案：D
65 、已知 a 是 int 型变量，则（）是对指针变量的正确定义和初始化。 A.int *p=a B. int *p=*aC. int *p=&a D. int p=&a 答案：D
66 、执行下面的程序段后，变量 ab 的值是（） int *var,ab=100; var=&ab;*var+=10;var+=10; A. 110 B. 100 C. 0 D. 120 答案：A 解析："var=&ab"的意思是var=ab的地址 " *var"的意思是取ab的地址所指向的值，" *var+=10"等价于ab+=10 "var+=10"由于var=ab的地址，所以此代码无意义 所以ab=(*var+=10) =*var+10; =ab+10 =100+10 =110
67 、设有定义和赋值：int a[10]={0,1,2,3,4,5,6,7,8,9}, *p; p=a+1;则能表示数组a中值为5的元素的表示式为（） A. a[4] B. *(p+4) C. a+5D. *p[5] 答案：B 解析：可以看一下T58的3个正确选项，把行直接删了就是一维数组 a中值为5的元素在第6位 A：改为a[5] B：以为p=a+1，所以 *(p+4)等价于 *(a+5)，正确 C、D：意义不明的代码
68 、int a[5][4],对于第 i 行j 列元素值引用正确的是（） A. *(*(a+i)+j) B. (a+i)[j] C. *(a+i+j)D. *(a+i)+j 答案：A 解析：见T58，B选项
69 、int a[5][4],对于第 i 行j 列元素值引用正确的是（） A. *(*(a+i)+j) B. (a+i)[j] C. *(a+i+j)D. *(a+i)+j 答案：A 解析：见T58，B选项，和68题是一样的，我没有打错啊
70 、若有定义 int (*p)[4],则标识符 p 表示（） A.是一个指向整型变量的指针B.是一个指针数组名 C.是一个行指针，指向一个含有 4 个整型元素的一维数组D.定义不合法 答案：C 解析：代码含义问题，请自行搜索
71 、下列程序段的输出结果为（）void fun(int *x, int *y){ printf("%d %d", *x, *y); *x=3; *y=4; }void main( ){ int x=1, y=2; fun(&y,&x); printf("%d %d",x,y);} A. 2 1 1 2 B. 1 2 1 2 C. 1 2 3 4 D. 2 1 4 3 答案：D 解析：fun(&y, &x)把y的地址传递给x，把x的地址传递给y， 即运行到printf("%d %d",*x,*y);时x=2,y=1; *x=3;*y=4;给x,y赋值时，由于fun(&y, &x)交换了传递位置， 把y的地址传递给x,把x的地址传递给y，所以运行到x=3;*y=4时， 主函数中的x=4,y=3
72 、若有定义和语句：char s[ 10]; s="abcd"; printf("%s\n",s);，则结果是（） A.输出 abcd B.输出 aC.输出 abcd(有空格) D.编译不通过 答案：D 解析：这里的s是一个数组包含10个char的首地址，它只可以在初始化的时候用 char s[10]="abcd"; char s[]="abcd"; char *s="abcd"; 这三种写法都是对的，但是都是初始化的时候使用
73 、当用户输入的字符串中含有空格时，应使用 （）函数读入字符串。 A. scanfB. gets C. getcharD. getc 答案：B
74 、将两个字符串 s1 和 s2 连接起来，正确的函数是 ( ) A. strcpy(s1,s2)B. strcat(s1,s2) C. strcmp(s1,s2)D. strlen(s1,s2) 答案：B 解析：A：将s2复制到s1 B：连接s1与s2 C：比较s1与s2大小（按ASCII码值大小比较），直到出现不同的字符或遇到"\0"为止s1=s2，返回0s1>s2，返回一个正整数s1<s2，返回一个负整数 D：计算字符串长度格式：strlen(字符数组);
75 、12.设有如下程序段：char s[20]="beijing",*p; p=s;，则以下叙述正确的是 ( ) A.可以用*p 表示 s[0] B. s 数组中元素的个数和 p 所指字符串长度相等 C. s 和 p 都是指针变量 D.数组 s 中的内容和指针变量 p 中的内容相等 答案：A
76 、有以下函数#includeint main( ){char a[20],b[20],c[20]; scanf("%s%s",a,b); gets(c); printf("%s%s%s\n",a,b,c); return 0;}程序运行时输入 this is a cat！ ，则输出结果是 ( ) A. thisisacat！;B. this is a C. thisis a cat！ D. thisisa cat！ 答案：C 解析：scanf按%s将数据赋值分别给a、b，但是scanf碰到空格就认为字符串结束， 于是字符串数组a被赋值"this"，b被赋值"is"，剩下“ a cat！” 这个部分是用gets函数来接收的，而gets函数碰到空格不会认为字符串结束 会全部赋值给c，于是c的内容是“ a cat！” 然后printf输出，就组成了"thisis a cat！"
77 、以下不能正确对字符串初始化的语句是 ( ) A. char str[]={"good!"};B. char *str="good"; C.char str[5]="good!";D. char str[6]={'g','o','o','d',' !','\0'}; 答案：C 解析：str只给了5个字符的空间，但"good!"需要6个字符（有一个是结束符） A、B会自动计算字符串所需的空间 D是以字符数组来看待str，而非字符串方式
78 、以下叙述正确的是（） A. C 语言允许 main 函数带参数，且参数的个数和形参名均可由用户任意指定 B. C 语言允许 main 函数带参数，形参名只能是 argc 和 argv C.当 main 函数带有形参时，传给形参的值一般从命令行得到 D.若有说明：int main(int argc, char *argv),则形参 argc 的值必须大于 1 答案：C
79 、对于一个联合类型的变量，系统分配的存储空间是（） A 、第一个成员所需的存储空间 B 、最后一个成员所需的存储空间 C 、 占用空间最大的成员所需的存储空间 D 、所有成员存储空间的总和 答案：C
80 、以下有关宏替换的叙述不正确的是（） A 、宏替换不占用运行时间B 、宏名无类型 C 、宏替换只是字符替换D 、宏名不能用小写字母表示 答案：D
81 、函数 f 定义如下，执行语句“sum=f(5)+f(3);”后，sum 的值应为（） int f(int m){ static int i=0; int s=0; for(;i<=m;i++)s+=i; return s;} A 、21B 、16 C 、15D 、8 答案：C 解析：先计算f(5),题干的for循环意思是从0到m的数的和，先得出f(5)=15 然后计算f(3)时，由于i在计算f(5)时不断自增到了6， 所以for循环中的i<=m这一条件未达到， 不会开始循环，所以f(3)=0 所以sum=f(5)+f(3)=15+0=15
82 、声明语句为“int a[3][4];”,下列表达式中与数组元素a[2][1]等价的是（） A 、*(a[2]+1)B 、a[9] C 、*(a[ 1]+2) D 、*(*(a+2))+1 答案：A 解析：见T58
83 、宏定义#define G 9.8中的宏名 G 表示 （） A 、一个单精度实数 B 、一个双精度实数 C 、一个字符串 D 、不确定类型的数 答案：C
84 、在定义一个结构体变量时，系统分配给它的内存是（） A 、结构体中第一个成员所需内存量 B 、结构体中最后一个成员所需内存量 C 、成员中占内存量最大者所需内存量 D 、各成员所需内存量的总和 答案：C
85 、根据下面的定义，能打印出字母"M"的语句是（）struct person{ char name[9] ；int age；}；struct person class[10]= {{"John" ，17}，{"Paul" ，19} ，{"Mary" ，18} ，{"Adam" ，16 } }； A 、printf("％c\n" ，class[3] ．name )； B 、printf("％c\n" ，class[3] ．name[l])； C 、Printf("％c\n" ，class[2] ．name[l])； D 、printf("％c\n" ，class[2] ．name[0])； 答案：D 解析：调用数组时， class[0]对应{"John" ，17} class[2]对应{"Mary" ，18} class[1]对应{"Paul" ，19} class[3]对应{"Adam" ，16 } 带有"M"的只有class[2]对应的{"Mary" ，18} 由于题干函数在一维数组class中嵌套了name数组， 所以“M”在class[2]中的name[0]处
86 、设有以下结构体定义： struct emproyer{ char name[8] ；int age；char sex；}staff；则下面的叙述不正确的是（） A 、struct 是结构体类型的关键字 B 、struct emproyer 是用户定义的结构体类型 C 、staff 是用户定义的结构体类型名 D 、nameage 和 sex 都是结构体成员名 答案：C
87 、下面程序的输出结果是（）#include#define P 2#define POWER(x)P*x*xmain() {int x= 1 ，y=2； printf("％d ，％d" ，POWER(x+y)，POWER(y+x))；} A 、18 ，18 B 、6 ，7 C 、6 ，6 D 、7 ，7 答案：B 解析：由于宏定义 #define POWER(x)P*x*x， 所以POWER(x+y)=P*x+y*x+y =2*1+2*1+2 =2+2+2 =6 POWER(y+x)=P*y+x*y+x =2*2+1*2+1 =4+2+1 =7 不要自作聪明地将x+y或y+x加括号
88 、若有以下定义和语句： struct student{ int num ;int age；}；struct student stu[3]= {{l001 ，20} ，{ 1002 ，19} ，{ 1003 ，2l} }；main(){ struct student *p；p=stu； ...}则下列引用中不正确的是（） A 、(p++)→num B 、p++ C 、(*p) ．numD 、p=&stu.age 答案：D
89 、下面程序的输出结果是（）#include#define P2#define POWER(x)P*(x)*(x)main(){ int x=l ，y=2； printf("％d ，％d" ，POWER(x+y)，POWER(y+x))； } A 、18 ，18 B 、6 ，7 C 、6 ，6 D 、7 ，7 答案：B 解析：见T87，完全一样的题目
90 、下面程序的输出结果是（）#include#define SUB(X ，Y) (X)*Ymain(){int a=3 ，b=4； printf("％d\n" ，SUB(a+b ，b++))；} A 、12B 、15 C 、16D 、28 答案：D 解析：由于宏定义#define SUB(X ，Y) (X)*Y 所以SUB(a+b ，b++)=(a+b)*b++ =7*4 =28 本题在a+b处加括号是由于(X)加了括号， 同时请对比T87，以加深此代码理解
91 、下面程序的输出结果是（）#include#define FUN(x ，y) x*ymain(){int a= 1 ，b=2； printf("％d" ，FUN(a+b ，a-b))；} A 、 -3 B 、1 C 、 -1 D 、0 答案：B 解析：由于宏定义 #define FUN(x ，y) x*y 所以FUN(a+b ，a-b)=a+b*a-b =1+2*1-2 =1
92 、下面程序的输出结果是（）#define MIN(x ，y) (x)<(y)?(x):(y) main(){int a= 1 ，b=2 ，c； c= 10*MIN(a ，b)； printf("％d" ，c)；} A 、1B 、10C 、2D 、20 答案：B 解析：由于宏定义 #define MIN(x ，y) (x)<(y)?(x):(y)所以c=10*MIN(a ，b)=10*(a)<(b)?(a):(b)= 10*(1)<(2)?(1):(2)=10*1=10
93 、下面程序的输出结果是（）struct st{ int x; int *y;}；int dt[4]={10 ，20 ，30 ，40}；struct st *p;aa[4]={50 ，&dt[0]，60 ，&dt[1],70 ，&dt[2]，80 ，&dt[3]}；main(){p=aa； printf("％d\n" ，++p →x); printf("％d\n",(++p) →x)； printf("％d\n" ，++(*p→y))；} A 、10B 、50C 、51D 、60 20606070 20212l31 答案：C 解析：struct st *p定义结构体指针， p=aa使得指针p指向结构体数组的首地址aa[0] ++p->x：由于->比++优先级高，所以输出结构体成员x的值再自增 所以输出的值为aa[0]+1=50+1=51 (++p) →x：由于( )优先级比->高，所以指针p先下移一个位置， 此时,aa[1]->x=60 ++(*p→y)：对aa[1]->y所指向的内容加1后输出, 即地址&dt[1]的内容20加1后输出21
94 、以下程序的运行结果为（）#includemain(){ struct date {int year ，month ，day； } today； printf("％d\n" ，sizeof(struct date))；} A 、6 B 、8 C 、10 D 、12 答案：D 解析：sizeof(struct date)是求字节数的运算符 三个整形，每个4字节，共3*4=12个字节数填空题（43题）
1 、十进制数 91 转换成二进制是_________，转换成八进制数是_________，转换成十六进制是_________。
答案：1011011； 133； 5B 解析：对十进制数除以进制数，保留余数后，继续对商除以进制数， 直到商为0，余数从右向左依次记录2、C 语言开发的 4 个步骤是_________ 、_________ 、_________ 、_________。
答案：编辑； 编译； 链接； 运行3 、一般情况下，在 C 语言中定义但未初始化的变量的值为_________。
答案：不确定的随机数4 、用 scanf 输入 1 个 double 型变量时，需要使用格式转换说明符_________，并且要使用取址运算符_________取得该变量的地址。
答案：%lf； &5 、一个 C 语言程序由若干个函数组成，其中必须有一个_________函数。
答案：main6 、定义函数时，若缺省函数类型标识符，函数返回值类型为 _________。
答案：int7 、求 1 至 100 的和，写作 for(s=0,i=1; _________ ;++i) s+=i;printf("%s\n",a);
答案：i<=100解析：求1~100的和，由于使用的是for循环，题干空处给出的是条件，由于i自增，为了让函数可以循环100次，所以条件必须为i<=100s+=i等价于s=s+i8 、int i=234,j=567; 函数 printf("%d%d\n",i,j) 的输出结果是_________。
答案：234567解析：printf函数中的两个整形之间没有空格，所以输出结果是连贯的9 、表达式: 10!=9 的值是_________。
答案：1解析：表达式的意思是10不等于9，显然这是正确的，所以值为110 、能正确表述判断闰年的C 语言表达式为____________________________________
答案：year%4==0&&year%100!=0||year%400==0解析：公历的置闰规则：普通闰年：公历年份是4的倍数（year%4==0），且不是100的倍数的（year%100!=0）世纪闰年：公历年份是整百数的，必须是400的倍数（year%400==0）普通闰年的两个条件是必须同时达到的，所以用逻辑与(&&)世纪闰年和普通闰年之间是”或“的关系，所以用逻辑或(||)11、设 float x,y; 使 y 为 x 的小数部分的表达式是_________。
答案：y=x-(int)x解析：由于强制类型转换，(int)x为float x的整数部分用单精度的x减去整数部分(int)x自然就是小数部分了12 、设 int i,a; 则执行语句：i=(a=23,a5),a+6; 后，变量 i 的值是_________。
答案：30解析：a=2*3=6，由于逗号运算符，取最后的表达式做值，所以i= a*5= 6*5= 30a+6虽然值为36，但是没有载体，不会表达出来逗号运算符虽然取最后的表达式作结果，但并不意味着前面的不需要计算13 、设 int a= 12,则执行完语句 a+=a-=a*a 后,a 的值是_________。
答案：-264解析：a+=a-=a*a实际上是a+=(a-=(a*a))，所以本题需要从后往前看a*a= 12*12= 144,a-=a*a等价于a-=144,即a= a-144= 12-144= -132a+=a-=a*a等价于a+= -132，而此时a已经等于-132了，所以a= -132+-132= -26414 、有以下函数定义：void fun(int n, double x){……} ，若使用到的变量定义为：int n= 10; double
x= 1.0,y=5.4; ，则对函数 fun 的正确调用语向是_________。
答案：fun(n,x)解析：变量的定义类型都是符合题干中函数的定义的，无需改变15 、 在调用函数时，如果实参是简单变量，它与对应形参之间的数据传递方式是_________ (传值或传地址这两种之间选填一个) 。
答案：传值解析：传地址在指针用的较多16 、在 C语言中，数组名代表_________。
答案：数组首个元素的地址17、己知 short int 类型变量在内存中占用两个字节，
有如下定义：short int array [10]={0,2,4}；, 则数组 array 在内存中所占字节数是 _________。
答案：20解析： short int 类型变量在内存中占用两个字节，array [10]定义了10个 short int 类型变量，所以在内存中所占字节数是2018 、若定义 int m[10]={9,4,12,8,2,10,7,5,1,3}; ，则 m[m[4]+m[8]] 的值是 _________。
答案：8解析：m[4]+m[8]= 2+1= 3m[m[4]+m[8]]= m[3]=819 、设有如下函数定义：
int fun (int k){ if (k<1) return 0; else if (k==1) return 1; else return fun (k- 1) + 1: }若执行调用语句：n=fun(3); ，则函数 fun 总共被调用的次数是_________。
答案：3解析：首先 n=fun(3)，进行了一次调用3被当做参数传进去后，程序会执行这句 else return fun(k-1)+1; 这就调用了第二次，而参数是3-1也就是22被当做参数传进去后，程序会执行这句 else return fun(k-1)+1;这就调用了第三次，而参数是2-1也就是11被当做参数传进去后，程序会执行这句 else if(k==1) return 1;不再递归调用20 、为保证整型变量 n 其在未赋值的情况下初值为 0 ，应选择的存储类别是_________ 。
答案：static21 、若有定义 int b[5][7];, 根据数组存储顺序，b[0][0] 为第1个元素，则第10个元素是___________
答案：b[1][2] 解析：定义的是5行7列的二维数组，所以第10个元素在第2行第3列所以第10个元素是b[1][2]22 、定义 int *pa[5],(*p)[5] ； 则表达式 sizeof(pa)的值是________ ，sizeof§的值是 ________。
答案：20；4或8 解析：*pa[5]：是一个数组，这个数组的内容（每一个元素）都是 int * 类型int类型占4个字节数，所以 sizeof(pa)的值是20 (*p)[5]：p指向一个数组，指向一块内存区域因为一个指针在32位的计算机上，占4个字节一个指针在64位的计算机上，占8个字节所以sizeof(p)的值是4或823 、设 int a=3,b=5,c=7; ，则表达式 ab!=0||c==b+a 的值为________。
答案：1 解析：ab值为0，所以ab值为0，表达式等价为0!=0||c==b+a 0!=0错误，值为0；c==b+a是给c赋值，等价于c=7 原表达式等价于0||7，值为124 、若已定义 int a,则表达式 a= 10,a+10,a++的值是 _______________。
答案：10 解析：a+10没有载体，又因为a++先用后增，所以a++的值为1025 、对于以下宏定义：#define MIN(a,b) a<b?b:a+ 1，执行语句 z= 10*MIN(2,5);后，z 的值为________。
答案：30 解析：由于宏定义#define MIN(a,b) a<b?b:a+1， 所以MIN(2,5)=（2<5?5,2+1） =2+1 =3 所以z= 10*3= 3026 、对于下面宏定义：
#define M(x) x*x
#define N(x, y) M(x)+M(y)
执行语句 z=N(2,2+4);后 z 的值为___________。
答案：18 解析：由于宏定义#define M(x) x*x和#define N(x, y) M(x)+M(y)， 所以z= N(2,2+4)= M(2)+M(2+4)=2*2+2+4*2+4=4+2+8+4=1827 、ANSI C 标准中定义的用于释放动态空间的函数名是________ ，使用该函数要包含的头文件 是________。
答案：free；malloc.h28 、定义语句为 char a[]=“Boot”,b[]=“Foot”; ，语句 printf("%d",strcmp(a+ 1,b+1));输出______。
答案：0 解析：strcmp()函数首先将s1字符串的第一个字符值减去s2第一个字符， 若差值为零则继续比较下去；若差值不为零，则返回差值 由于题干中"a+1""b+1"分别代表的是a[]和b[]的第二个字符，都是"o"， 所以ACSII码差值为0，继续向后比较，都是一样的所以差值为0，输出就是0 简单来说就是跳过了第一个字符再进行比较29 、设有数组定义:char array[]=“China”;则数组 array 所占的存储空间为____________个字节。
答案：6 解析：原数组相当于 char arrays[] = {'C', 'h', 'i', 'n', 'a', '\0'}; 所以是6个字符30 、有结构体定义如下：
struct person
{ int ID;
char name[20];
struct {int year, month, day;}birthday;
}Tom;
将 Tom 中的 day 赋值为 26 的语句为____________。
答案：Tom.birthday.day=26 解析：将"Tom"中的"birthday"中的"day"赋值为2631 、int x, *p; p=&x; 已知 x 的地址为 0x0028FF1C ，则 p+ 1=____________。
答案：0x0028FF20 解析：p= &x= 0x0028FF1C 因为x为整型，占4个字节， 所以p+ 1= 0x0028FF1C+4 =0x0028FF2032 、int m=5, *p=&m ；对变量 m 的间接访问为____________。
答案：*p 解析：*p=&m，*p表示此指针指向的内存地址中存放的内容没有直接p=m，而是先指向m的地址，再解析地址中的值33 、 数组名实质上是一个____________。
答案：常量指针34 、 int a[3][2];已知&a[0][0]等于 0x0028FF1C ，则 a+ 1=____________ ，a[0]+1=____________。
答案：0x0028FF2C；0x0028FF20 解析：一个整型占4个字节，数组有a[3][2]有6个整型a+1中"1"的大小指的是整个数组的所占大小,例如数组a[4]，&a +1实际上是 a[5]，跳过一个数组所以a+1= 0x0028FF1C+sizeod(int[3][2]) = 0x0028FF1C+3*2*4 =0x0028FF2Ca[0]+1中的"1"的大小指的是一个元素所占大小，例如数组a[4]，&a[0] +1实际上是 a[1]，a[0]+1实际上表示指针a[0][1]所以a[0]+1=0x0028FF1C+4=0x0028FF2035 、 申请动态内存空间的函数包括____________和____________。
答案：malloc；free36 、若有 定 义 int a[3][3]={{1,2,3}, {4,5,6}}; int *p,(*q)[3]=a; p=&a[0][0];
则 * ( * (q+ 1)+2) 等于 ________ ，
( * p) * ( * (p+2)) * ( * (p+4))等于_______ ，(*++q)[1]的值为_______。
答案：6；15；6 解析：*(*(q+ 1)+2)：指第2行第3列的数，值为6 (*p)*(*(p+2))*(*(p+4))：因为p=&a[0][0]，所以*p指第1行第1列的数 *(p+2)指第1行第3列的数；*(p+4)指第2行第2列的数 所以值为1*3*5=15 (*++q)[1]：等价于(*q+1)[1]，指第2行第2列的数，为537、有以下语句 char x[]=“12345”; char y[]={‘1’,‘2’,‘3’,‘4’,‘5’}; 则数组 x 的长度为____________，数组 y 的长度为____________。
答案：6；5 解析：char x[]="12345"等价于char x[]={'1','2','3','4','5','\0'}38 、若有语句：char s[10]=“1234567\0\0”; 则 sizeof(s)=____________ ，strlen(s)=____________。
答案：10；7 解析：字符数组s的大小只和c[10]中的10有关，定义了大小为10个char， char大小为一个字节，所以c的大小是10个字节，所以sizeof(s)=10 strlen遇到'\0'就停止，所以strlen(s)=739 、预处理命令必须以____________开头。
答案：#40 、struct st{ int a; double d;}*p;则变量 p 在内存中所占字节数为____________。
答案：8 解析：在内存中所占字节数为最大的字节数 最大的变量内存的大小为double的8字节41、struct st{int age；int num；}stul，*p；p=&stul；则对 stu1.num 访问的其他两种形式为____________、____________.
答案：p->num；(*p).num 解析：p->num：定义的结构体类型->定义的结构变量(*p).num：因为p=&stul，所以*p=stul42、struct {int x;char *y}t[]={1,”ab” ,2,”cd” },*p=t;则执行 sizeof( p)的结果为____________;若执行++p->y 的结果为____________ ；若执行 (++p) ->y 的结果为____________。
答案：8；b； 解析：t[]={1,”ab” ,2,”cd” }={'1','a','b','\0','2','c','d','\0'}sizeof( p)：由于*p=t，所以sizeof(p)=8t有两个元素，都为结构体。第一个是1和ab，第二个是2和cd++p->y：由于char *y将y定义为字符，取当前p指向的对象的成员y，即*(p->y) = a，随后++(p->y)表示指针向后跳一个，指向b(++p)->y：++p导致p指向第二个结构体，(++p)->y取当前p指向的对象的成员y，即*((++p)->y) = c读程序题（30题）
1、下面程序的输出结果是？#includeint main( ){ int i=010,j=10,k=0x10; printf("%d,%d,%d\n",i,j,k); return 0;}答案：8，10，16解析：i为八进制，所以i=1*8^1=8j为十进制，所以j=1*10^1=10k为十六进制，所以k=1*16^1=16
2、写出下面程序的运行结果#includeint main( ){ char a,b,c,d; a=getchar(); b=getchar(); scanf("%c%c",&c,&d); putchar(a); putchar(b); printf("%c%c",c,d); return 0;}如果从键盘输入 (从下面一行的第一列开始)1234则程序的输出结果是？答案：12解析：getchar()是一次读一个字符putchar()只能输出一个字符
3、写出下面程序的运行结果#includeint main( ){ int a; float b,c; scanf("%3d%3f%4f",&a,&b,&c); printf("a=%4d,b=%f,c=%g\n",a,b,c); return 0;}如果从键盘输入 (从下面一行的第一列开始)1234567.89则程序的输出结果是？答案：a=123,b=456.000000,c=7.89解析：scanf使a、b为3位，c为4为因为a为int型，所以a=123因为b为float型，所以小数点后有6位数，所以b=456.000000虽然c也为float型，但因为printf中c=%g，将不影响数字大小0省略了所以c=7.89
4、下面程序的输出结果是？#includeint main( ){ char ch=’A’+ 10; printf("C=%c,C=%d,c=%c,c=%d\n",ch,ch,ch+32,ch+32); return 0;}答案：C=K，C=75，C=k，C=107解析：本题考查ASCII码，对照ASCII码找出数字对应的字符即可注意%c输出字符，%d输出数字
5、下面程序的输出结果是？#includeint main(){ int x=5,y=4,z=3; if(x==y)z=x; x=y; y=z; printf("%d,%d,%d\n",x,y,z);}答案：x=4，y=3，z=3解析：因为x!=y，所以"z=x"这段无效，只看"x=y; y=z;"所以x=y=4，y=z=3，z不变
6、下面程序的输出结果是 #includeint main(){ int a,b; for(a=1,b=1;a=20) break;if(b%3= =1){ b+=3;continue;}b=-5; } printf(“%d\n”,a); }答案：8 解析：每次循环b增加3，a增加1，且当b>20（此时b=22）时跳出循环，结束程序。 所以b从1增加到22，有（22-1）/3=7次循环，所以a=1+7=8 b=-5是干扰部分
7、下面程序的运行结果是？#include int main( ){ int i, j; for(i=1;i<=4;i++) {for(j=1;j<=i;j++)printf(“*”);printf(“\n”); } return 0;}答案：**********解析：for(i=1;i<=4;i++)推进层数，for(j=1;j<=i;j++)推进每层的"*"数
8、下面程序的输出结果是 #include int main(){ int x=l ，y=0 ，a=0 ，b=0； switch(x) {case l：switch(y){ case 0: a++; break; case 1 ：b++；break；}case 2：a++；b++; break； } printf("a=％d, b=％d\n" ，a ，b)； }答案：a=2，b=1 解析：x=1，走switch(y)，因为y=0，所以a的值+1。由于switch(x)的case l：结束没有break，所以继续case 2，a、b都+1。所以a=2，b=1
9、有下列程序段，程序的输出结果是 char ch;int s=0;for(ch=’A’;ch<’Z’;++ch)if(ch%2= =0)s++;printf(“%d”,s);答案：12解析：A~Y中有多少字母的ASCII码可以被2整除
10、下面程序的运行结果是？ #include void s(int a, int *b) { int t;t=a; a=*b;*b=t; } int main() { int x=7,y= 10;s(x,&y);printf(“%d,%d\n”,x,y);return 0; } 答案：7，7 解析：a=*b忽略就行，影响a的地址，不影响a的值
11、下面程序的运行结果是？ #include int Min(int x, int y) {return x<y?x:y; } int main( ) {int x= 13,y=5,z=22;printf("%d\n", Min(x,Min(y,z)));return 0; }答案：5 解析：定义函数Min(int x, int y)的作用就是return一个小的数， x<y则return x，否则return y Min(y,z)结果为y， Min(x,Min(y,z)等价于Min(x,y)，结果为y，y=5
12、下面程序的运行结果是？#include int fun(int i) { return i*i; } int main( ) {int i=0;i=fun(i);for(; i<3;i++){ static int i=1; i+=fun(i); printf("%d, ", i);}printf("%d\n",i);return 0; }答案：2，6，42，3 解析：由于static使函数就被定义成为静态函数 通俗点，就是使得for(; i<3;i++)语句块中的"i”独立出来，并且值会被保留 第一次for循环：i=1+ 1*1= 2 第二次for循环：i= 2+2*2= 6 第三次for循环：i=6+6*6= 42 至此，由于i=3，不符合for循环的运行条件，循环结束 而for函数"( )"内的"i"与语句块中的"i"不是一个东西， 所以最后的printf("%d\n",i)所输出的是循环的次数：3
13、下面程序的运行结果是？#include double F(int x) {return(3. 14*x*x); } int main() {int a[3]={1,2,3};printf("%5.2f\n",F(a[ 1]));return 0; }答案：12.56 解析：%5.2f表示五位有效数字且小数点后有两位数字的浮点型 其中小数点算一位数长，如果实际位数小于m，则要在前补齐空格 a[1]=2，所以F(a[1])= F(2)= 12.56 数长和小数点后位数都完全符合%5.2，所以原样输出
14、下面程序的运行结果是？#include #define N 4 void fun(int a[][N],int b[]) {int i;for(i=0;i<N;i++)b[i]=a[i][i]-a[i][N-1-i]; } int main() {int x[N][N]={{1,2,3,4}, {5,6,7,8}, {9,10,11,12}, {13,14,15,16}},y[N],i;fun(x,y);for(i=0;i<N;i++)printf("%d,",y[i]);printf("\n");return 0; }答案：-3,-1,1,3 解析：y[0]= a[0][0]-a[0][4-1-0]= 1-4= -3 y[1]= a[1][1]-a[1][4-1-1]= 6-7= -1 y[2]= a[2][2]-a[2][4-1-2]= 11-10= 1 y[3]= a[3][3]-a[3][4-1-3]= 16-13= 3
15、下面程序的运行结果是？ #include int f(int a, int b) {static int m,i=2;i+=m+1;m=i+a+b;return m; } int main() {int p,i;for(i=1;i<=2;i++){ p = f(4, 1); printf("%d\t",p);}return 0; }答案：8（空7格）17 解析：for(i=1;i<=2;i++)：运行两次 static定义静态局部变量，即使声明时未赋初值， 编译器也会把它初始化为0 所以static int m,i=2;等价于static int m=0,i=2; 第一次循环：i= i+m+1= 2+0+1= 3m= i+a+b= 3+4+1= 8 第二次循环：i= i+m+1= 3+8+1 =12m= i+a+b= 12+4+1 =17 空7格的原因：（了解一下就行，不重要）"\t"是水平制表符，作用是将当前位置移动到下一个tab位置 假定某个字符串在制表符\t的前面有n个字符， 那么\t将跳过8-n%8个空格，（将1带入n，为7格） 即：将光标移到最接近8的倍数的位置， 使得后面的输入从此开始。
16、下面程序的运行结果是？ #include void func(char s[]) {int i,j;char c;for(i=0,j=strlen(s)-1; i s[0]= s[4]= o s[j]= c=> s[5]= h 数组变为oellh第二次循环：c= s[i]= s[1]= e s[i]= s[j]=> s[1]= s[3]= l s[j]= c=> s[3]= e 数组变为olleh
17、下面程序的输出结果是？ #include int main() {int i, x[3][3] = {1,2,3,4,5,6,7,8,9};for (i=0; i<3; i++) printf("%3d", x[i][i]);printf("\n");return 0; } 答案：（空2格）1（空2格）5（空2格）9 解析：for (i=0; i<3; i++)：运行3次 第一次循环：x[0][0]= 1 第二次循环：x[1][1]= 5 第三次循环：x[2][2]= 9 空2格的原因见T13
18、下面程序的运行结果是？#include int m= 13; int fun2(int x, int y) { int m=3;return(x*y-m); } int main() { int a=7, b=5;printf("%d\n",fun2(a,b)/m);return 0; }答案：2 解析：函数fun2(a,b)返回的x*y-m= 7*5-13= 22 由于"%d"，fun2(a,b)/m= 22/13= 2
19、下面程序的运行结果是？(ASCII码，‘0’=32；‘9’=41) #include int main() {char ch[7]="65ab21";int i, s=0;for(i=0; ch[i]>='0' && ch[i]='0' && ch[i]<='9';i+=2)：循环1次，一次后i=2，ch[i]= 97，不符合循环条件 第一次循环：s=10*s+ch[i]-'0' =10*0+54-48 =6 这题很离谱，题干里给的ASCII码是错误的， 实际上‘0’=48；‘9’=57，不做评价
20、下面程序的运行结果是？ #include f(char s[ ]) { int i,j;i=0;j=0;while(s[j]!='\0')j++;return (j-i); } int main() {printf("%d\n",f("ABCDEF"));return 0; }答案：6 解析：char s[ ]="ABCDEF"，实际上有7个字符，第七位为"\0"所以while(s[j]!='\0') 要循环6次，直到s[j]='\0'j-i= 6-0= 6
21、下面程序的运行结果是？ #include int p(int x, int y, int* z); int main() {int x, y, z;x = 5; y = 7; z = 4;p(7,x + y + z, &x);printf("%d ，%d ，%d", x, y, z);return 0; } int p(int x, int y, int * z) {return *z = y - x - *z; }答案：4，7，4 解析：int * z对应&x，值为x=5 所以return *z= y - x - *z=> *z= (x + y + z)-7-x=16-7-5=4 所以x=4
22、下面程序的运行结果是？ #include int main( ) {int array[]={6,7,8,9,10},*ptr;ptr=array; *(ptr+2) +=2;printf("%d, %d\n", *ptr, *(ptr+2));return 0; }答案：6，10 解析：*ptr= ptr[0]= 6 *(ptr+2)= +2=> *(ptr+2)= *(ptr+2)+2=ptr[2]+2= 8+2=10
23、下面程序的运行结果是？ #include void fun(int *a, int *b) {int *c; c=a; a=b; b=c; } int main( ) {int x=3,y=5, *p=&x,*q=&y;fun(p,q);printf("%d, %d\n", *p, *q);fun(&x,&y);printf("%d, %d\n", *p, *q);return 0; } 答案：3，53，5 解析：*p=&x：x的地址付给p，p里存的是一个数值x 所以*p=3，*q=5 fun(p,q)为无效代码，格式不符，跑不出东西 p=&x：p的内存地址指向x所在的内存地址 fun(&x,&y)也一样，没用
24、下面程序的运行结果是？#includeint main( ) {int array[]={1,2,3,4,5},y=0,i,*p;p=&array[4];for(i=0; i<=3; i++){y=y+*p; p--;}printf("%d\n", y);return 0; } 答案：14 解析： for(i=0; i<=3; i++)：运行4次 第一次循环：y= 0+array[4]= 0+5= 5 第二次循环：y= 5+array[4]-1=5+4= 9 第三次循环：y= 9+array[4]-1-1= 9+3= 12 第四次循环：y= 12+array[4]-1-1-1= 12+2= 14
25、如果输入 ABC ，请写出运行结果 #include #include int main() { char ss[10]="1,2,3,4,5";gets(ss);strcat(ss,"6789");printf("%s\n",ss); } 答案：ABC6789 解析：gets(ss)记录输入的ABC strcat(ss,"6789")连接"ABC"与"6789"，结果放在"ss"中
26、下面程序的运行结果是？#include int main() { char s[]="12a021b230";int i,v0,v1,v2,v3,vt;v0=v1=v2=v3=vt=0;for(i=0;s[i];i++){switch(s[i]-'0') { case 0: v0++;case 1: v1++;case 2: v2++;case 3: v0++; break;default: vt++; }}printf("%d,%d,%d,%d,%d\n",v0,v1,v2,v3,vt);return 0; } 答案：10，4，7，0，2 解析： for(i=0;s[i];i++)：从头走到尾，直到一维数组结束，共运行10次第一次循环：v0=1;v1=1;v2=1;v3=0;vt=0第二次循环：v0=2;v1=1;v2=2;v3=0;vt=0第三次循环：v0=2;v1=1;v2=2;v3=0;vt=1第四次循环：v0=4;v1=2;v2=3;v3=0;vt=1第五次循环：v0=5;v1=2;v2=4;v3=0;vt=1第六次循环：v0=6;v1=3;v2=5;v3=0;vt=1第七次循环：v0=6;v1=3;v2=5;v3=0;vt=2第八次循环：v0=7;v1=3;v2=6;v3=0;vt=2第九次循环：v0=8;v1=3;v2=6;v3=0;vt=2第十次循环：v0=10; v1=4;v2=7;v3=0;vt=2
27、下面程序的运行结果是？#include #define P 2 #define POWER(x) P*x*x main() { int x= 1 ，y=2；printf("％d，％d" ，POWER(x+y)，POWER(y+x))； }答案：6，7 解析：POWER(x+y)= 2*1+2*1+2= 2+2+2=6 POWER(y+x)= 2*2+1*2*1= 4+2+1= 7
28、下面程序的运行结果是？#include #define SUB(X,Y) (X)*Y main() { int a=3，b=4；printf("％d\n", SUB(a+b，b++))； } 答案：28 解析：SUB(a+b，b++)= (3+4)*4++= 7*4= 28
29、下面程序的运行结果是？#include struct abc {int a,b,c;}; int main() {struct abc s[2]={1,2,3,4,5,6}; int t;t=s[0].a+s[1].b;printf(“%d\n”,t);return 0; } 答案：6 解析：在main函数中定义了一个struct abc类型的数组 struct abc {int a,b,c;}所以3个数一组， struct abc s[2]={1,2,3,4,5,6};可理解为{{a,b,c}{a,b,c}}，列数为2的一维数组，一列3个数 即：同时分别利用{1,2,3}及(4,5,6}对数组中两个元素进行初始化在该结构体，依次对其中的a、b、c三个变量进行初始化 故s[0].a=1，s[1].b=5，所以本题输出为6
30、下面程序的运行结果是？ #include struct cmp{int x,y}cn[]={1,3,2,7}; int main() { printf(“%d\n”,cn[0].y*cn[1].x); return 0;} 答案：6 解析：思路和上一题一样，struct cmp{int x,y}所以2个数一组 cn[0].y=3，cn[1].x=2 所以cn[0].y*cn[1].x= 3*2= 6程序填空（17题）
答案仅供参考，部分答案不是唯一的
1、按照输出结果，完成下面程序#include int main(){ int year, month,day; printf("请用标准格式输入一个日期 (YYYY-MM-DD) ：") ; scanf("_____(1)_____",_____(2)_____); printf("_____(3)_____\n",_____(4)_____); return 0;}运行结果：请用标准日期格式输入一个日期 (YYYY-MM-DD) :若用户从键盘输入：2022- 12- 12则输出结果为：2022 年 12 月 12 日答案： (1)：%d-%d-%d (2)：&year,&month,&day (3)："%d年%d月%d日" (4)：year,month,day解析： (1)year, month,day;都是int型，所以用%d (2)"&"使得"%d"取得对应位置 (3)输出结果带"年 月 日"，int型只传递数值 (4)按顺序对应前面的位置
2、完成下面程序，计算圆的面积,结果保留两位小数： #include int main(){ double pi=3. 14159;/*定义只读常量 pi*/ double r; scanf("_____(1)_____", &r); printf(" area=_____(2)_____",_____(3)_____); return 0;}答案： (1)：%lf (2)：%.2lf (3)：pi*r*r 解析： (1)"r"是double型，所以用"%lf" (2)结果保留两位小数，所以用"%.2lf" (3)原面积公式对应"%.2lf"的格式
3、完成下面程序，利用 for 循环语句计算求和问题： S1000= 1 - 1/2 + 1/3 - 1/4 +...+ 1/999 - 1/1000#include int main(){ float S=_____(1)_____; int i,sign=- 1; for(i=2;_____(2)_____;i++) {S=S+_____(3)_____;sign=-sign; } printf("%.5f\n",S); return 0;} 答案： (1)：1 (2)：i1000才能停下，所以i<=1000是for循环的条件 (3)"1/i*sign"使得2~1000变为1/2~1/1000
4、完成下面的程序，求 1 !+3 !+5 !+……+n !的和。#include void main(){ long int f,s; int i,j,n; _____(1)_____; scanf("%d",&n); for(i=1;i<=n;_____(2)_____) {f=1;for(j=1; _____(3)_____;j++)_____(4)_____;s=s+f; } printf("n=%d,s=%ld\n",n,s);} 答案： (1)：s=0 (2)：i+=2 (3)：j<=i (4)：f*=s 解析： (1)for循环从1开始，所以初始量为0，"s=s+f"确定s为总和 (2)求 1 !+3 !+5 !+……+n !的和，所以每次i需要+2 (3)每次乘到n时停止，n是根据外层for循环定的 (4)这部分负责将单个的n!算出
5、完成下面的程序，求两个非负整数的最大公约数和最小公倍数。 #include void main() { int m,n,r,p,gcd,lcm; scanf("%d%d",&m,&n); if(m<n){p=m,m=n;n=p; } p=m*n; r=m%n; while(r != 0 ) {m=n;n=r;_____(1)_____; } gcd=_____(2)_____; lcm=p/gcd; printf("gcd=%d,lcm=%d\n",_____(3)_____); } 答案： (1)：r=m%n (2)：n (3)：gcd,lcm 解析： (1)变量 r 来存储 m 对 n 取模（即余数）。通过循环计算 m 对 n 取模的结果，直到余数等于0，此时 n 就是最大公约数 (2)此时 n 就是最大公约数，所以gcd=n (3)使用 printf() 函数打印最大公约数和最小公倍数的值
6、编写递归函数实现求两个整数的最大公约数，主函数读入待求的两个整数并调用公约数函求解，输出结果。#includeint gcd ( int m, int n){ int r; r=m%n; if_____(1)_____,return n; return_____(2)_____;}int main( ){ int m, n; scanf("%d%d", &m, &n); printf ( "Gcd of m and n is: %d\n",_____(3)_____); return 0;} 答案： (1)：(r==0) (2)：gcd(m,r) (3)：gcd(m,n) 解析： (1)计算 m 对 n 取余数的结果 r。然后使用条件判断语句判断 r 是否等于0，如果等于0，则表示 n 是最大公约数，直接返回 n。(2)如果 r 不等于0，则调用递归函数 gcd()，将 n 作为新的 m，将 r 作为新的 n，继续计算新的余数，直到最终余数等于0，返回最大公约数。 (3)调用递归函数 gcd()，传入 m 和 n 作为参数，获取最大公约数的结果。最后使用 printf() 函数打印最大公约数的值
7、完成下面程序，给一维数组输人数据后，找出下标为偶数的元素的最小值并输出。 #include int main ( ){ int a[ 10], min; int i; for (i=0; i<10;i++)_____(1)_____ min=a[0]: for (i=2;ia[i] 解析： (1)使用 for 循环遍历数组，通过 scanf() 函数从键盘输入数组元素的值，并存储在相应的数组位置上 (2)使用 for 循环遍历数组，从下标为2的元素开始，每次移动两个位置，即找出下标为偶数的元素 (3)使用条件判断语句比较当前元素 a[i] 与 min 的值，如果 a[i] 小于 min，则将 a[i] 赋值给 min
8、以下程序求得二维数组 a 的每行最大值，并存储在数组b 中，请将程序补充完整。#include void fun (int ar[ ][4], int bar[], int m, int n){ int i, j; for(i=0;i<m;i++) {_____(1)_____;for(j=1;jbar[i])bar[i]=ar[i][j]; }}int main (){ int a[3][4] = {{12,41,36,28}, { 19,33,15,27}, {3,27,19,1}}, b[3], i; _____(2)_____; for (i=0;i<3;i++)printf ("%4d", b[i]); printf("\n"); return 0;} 答案： (1)：bar[i]=ar[i][0] (2)：fun(a,b,3,4) 解析： (1)使用两个嵌套的 for 循环遍历数组ar，从每行的第一个元素开始，找出每行中的最大值，并将最大值存储在数组 bar 中相应的位置上 (2)调用函数 fun(a, b, 3, 4)，将数组 a 和其行数、列数作为参数传递给函数 fun()
9、完成下面程序，给一维数组输入数据，调用函数 fun 找出下标为偶数的元素的最小值，在主函数中输出该值。#includeint fun(int *arr,int n){int i, min; min=arr[0]; for(i=2;i<10;i+=2 )if(_____(1)_____) min=arr[i]; return min;}int main(){ int i,a[ 10]; for(i=0;i<10;i++)scanf("%d", _____(2)_____); printf("最小值为:%d\n",_____(3)_____); return 0;}答案： (1)：min=arr[i] (2)：&a[i] (3)：fun(a,10) 解析： (1) (2) (3)
10、下列程序读出文本文件 C:\dream.txt 中的内容， 将所有小写字母改为大写字母并输出，请将程序补充完整。 #include #include int main() {_____(1)_____;char ch;fp=fopen("C:\\dream.txt","r");if(fp==NULL){ printf("file error!\n"); exit(0);}while((ch= _____(2)_____)!=EOF){ if(ch>='a' && ch<='z') { _____(3)_____; } putchar(ch);}putchar('\n');_____(4)_____; } 答案： (1)：FILE *fp (2)：fgetc(fp) (3)：ch-=32 (4)：fclose(fp) 解析： (1) (2) (3)
11、完成程序，将数组 array 中的数据逆序存放 #include int main( ) { int array[ 10], i,j,t;for(i=0;i<=9;i++){scanf("%d",_____(1)_____);}i=0;j=9;while(i<9){t=*(array+i); _____(2)_____; _____(3)_____;i++;j--; }for(i=0;i<=9;i++){printf("%3d",_____(4)_____);}return 0； } 答案： (1)：&array[i] (2)：*(array+i)=*(array+j) (3)：*(array+j)=t (4)：array[i]
12、完成程序，将十进制转变为二进制，二进制的每一位存放在数组中 #include int main( ) {int b[16],x,k,r,i;printf("输入一个整型数：");scanf("%d",_____(1)_____);k=- 1;do{ r=x%2; k++; *_____(2)_____=r;x=x/2'} while _____(3)_____；//对二进制进行输出for(_____(4)_____;_____(5)_____;i--){printf("%ld", *_____(6)_____);}return 0; } 答案： (1)：&x (2)：(b+k) (3)：(k=0 (6)：*(b+i)
13、给出矩阵的主对角线之和并找出最大元素 #include int f(int a[3][3], int *max, int n) {int i,j,s=0;*max=a[0][0];for(i=0; i<n;i++){ s = s+ _____(1)_____; for(j=0; _____(2)_____; j++) { if(_____(3)_____) *max=a[i][j]; }}return s; } int main( ) {int a[3][3]={1,-2,9,4,-8,6,7,0,5}; int max,sum;sum=f(_____(4)_____);printf("sum=%d, max=%d\n", sum, max);return 0; } 答案： (1)：a[i][i] (2)：j<n (3)：*max
14、用以下delnum 函数实现删除字符串 s 中的数字字符 delnum(char *s) {int i,j;for( i=0,j=0; s[i]!='\0'; i++){ if_____(1)_____ { s[j]=s[i];_____(2)_____; }}_____(3)_____; } 答案： (1)：s[i] >=‘0’ &&s[i] <= ‘9’ (2)：j++ (3)：s[j] = ‘\0’
15、完成以下程序，该程序统计一个字符串中单词的个数，单词以空格分隔。 #include #include int main( ) {int i,num=0,word=0;char str[80];_____(1)_____;printf("%s",str);for(i=0;i<_____(2)_____;i++){if(str[i]==' ') { word=0; } else if { word=1; num++; }}printf("%d\n",num);return 0 }答案： (1)：gets(str) (2)：i<strlen(str)
16、有五个学生，每个学生有 3 门课的成绩，从键盘输入以上数据 (包括学生号，姓名，三 门课成绩) ， 计算出平均成绩，设原有的数据和计算出的平均分数存放在磁盘文件"stud"中。 请将程序补充完整。 #include struct student {char num[6];char name[8];int score[3];float avr; } stu[5]; main() {int i,j,sum;FILE *fp;for(i=0;i<5;i++){ printf("\n please input No. %d score:\n",i); printf("stuNo:"); scanf("%s",stu[i].num); printf("name:"); scanf("%s",stu[i].name); sum=0; for(j=0;_____(1)_____;j++) {printf("score %d.",j+1);scanf("%d",&stu[i].score[j]);sum+=stu[i]. _____(2)_____; } stu[i].avr=sum/3.0;}fp=fopen("stud","w");for(i=0;i<5; i++)if(fwrite(&stu[i],sizeof(_____(3)_____), 1,fp)!=1) printf("file write error\n");fclose(fp); } 答案： (1)：j<=2 (2)：.score[j] (3)：struct,student
17、 以下程序的功能是按学生姓名查询其排名和平均成绩，查询可连续进行，直到键入 0 时结束，请在空白处填入正确内容。#include#include#_____(1)_____NUM 4struct student{int rank；char * name；float score；}；_____(2)_____ stu[ ]={3 ，"Tom" ， 98.3，4 ，"Mary" ，78.2，l ，"Jack" ，95. 1，2 ，"Jim" ， 90.6，}；main(){ _____(3)_____ str[ 10]； int i; do { printf("Enter a name：")；scanf("％s" ,_____(4)_____)；for(i=0;i=NUM) printf("Not found\n")； } while(_____(8)_____(str ，"0")!=0) ；} 答案： (1)：define (2)：struct (3)：char str[10] (4)：str (5)：i<NUM (6)：strcmp(stu[i].name,str)==0 (7)：break (8)：strcmp编程题（6题）
22级考的是第3题
1 、编写程序:
(1) 定义函数 int fun(int a[], int m); 实现查找小于或者等于 m 的所有素数并放在数组中，
函数返回所求出的素数的个数。
(2) 定义主函数，主函数中首先定义一个数组 array；接着从键盘输入任意一个整数 m (<1000) ，
然后调用函数 fun 输入数组和整数 m ，并将查找出的素数和素数个数打印出来。
#include int prime(int num)//定义了一个函数isPrime来判断一个数是否为素数 {if (num < 2) { return 0;}for (int i = 2; i*i <= num; i++) { if (num % i == 0) {return 0; }} return 1; } int fun(int a[], int m) //定义了函数fun来查找小于或等于给定整数m的素数， { 并将结果存储在给定的数组中int count = 0;for (int i = 2; i <= m; i++) { if (prime(i)){a[count] = i;count++; }}return count; } int main() {int array[1000]; //定义了一个数组array和一个变量mint m;printf("输入一个整数m: ");scanf("%d", &m); //然后从键盘输入一个整数mint count = fun(array, m); //调用函数fun来输入数组和整数mprintf("小于或等于的质数 %d: ", m);for (int i = 0; i < count; i++) { printf("%d ", array[i]);//将查找到的素数打印出来。}printf("\n");printf("质数数量为: %d\n", count);//将查找到的素数个数打印出来。return 0; }2、编写程序:
(1) 定义函数 int BubbleSort(int a[],int n),用冒泡法将数组元素按照从大到小的顺序 排序。 (4 分)。
(2) 定义输入函数 void Input(int a[],int n); 实现从键盘输入数组 a 中的 n 个元素(3 分)。
(3) 定义输入函数 void Print(int a[],int n); 实现输出数组 a 中的 n 个元素(3 分)。
(4) 定义主函数，主函数中首先定义一个含 15 个元素的数组；
接着调用 Input 函数输入 10 个数组元素；
在主函数中调用BubbleSort 函数对数组的元素进行排序，
并将排序的结果使 用 Print 函数打印输出 (5 分) 。
#include void Input(int a[], int n) //定义了Input()函数用于输入数组的元素 {printf("请输入 %d 个元素：\n", n);for (int i = 0; i < n; i++) { scanf("%d", &a[i]);} } void Print(int a[], int n)//定义了Print()函数用于输出数组的元素 {printf("数组的元素为：\n");for (int i = 0; i < n; i++) { printf("%d ", a[i]);}printf("\n"); } int BubbleSort(int a[], int n)//在BubbleSort()函数中使用冒泡排序算法 { 对数组 a 进行从大到小的排序for (int i = 0; i < n-1; i++) { for (int j = 0; j < n-i-1; j++){if (a[j] < a[j+1]) { int temp = a[j]; a[j] = a[j+1]; a[j+1] = temp;} }} } int main(){int a[15];//定义了含有15个元素的数组aint n = 10;Input(a, n);//调用Input()函数输入10个数组元素BubbleSort(a, n); //使用 BubbleSort() 函数对数组进行排序Print(a, n);//使用 Print() 函数输出排序后的数组元素return 0; }3、编写程序:
在考生文件夹下，给定程序 pingyou.c 的功能是：学习优良奖的条件如下：
所考 5 门课的总成绩在 450 分 (含) 以上；或者每门课都在 88 分 (含) 以上。
输入某学生 5 门课的考试成 绩，输出是否够学习优良奖的条件。
#include int main(){int scores[5]; //声明一个大小为5的整型数组scores来存储某学生的5门课的考试成绩int sum = 0; //变量total被初始化为0，用于存储所有成绩的总和int excellent = 0; //excellent被初始化为0，用于标记是否符合学习优良奖的条件printf("请输入某学生5门课的考试成绩（每门成绩一行）：\n");for (int i = 0; i < 5; i++) { scanf("%d", &scores[i]);//依次输入5门课的考试成绩，并将成绩存储到数组scores中 sum += scores[i]; //计算总和sum if (scores[i] = 450) //程序判断总成绩是否大于等于450，{ 如果是，则将isExcellent置为1， excellent = 1; 表示满足学习优良奖的条件。}if (excellent)//根据isExcellent的值，程序输出对应的提示信息，{ 告知学生是否符合学习优良奖的条件 printf("学生符合学习优良奖的条件\n");} else { printf("学生不符合学习优良奖的条件\n");}return 0; }4、编写程序:
输入一个 3 ×4 的二维整数矩阵，要求实现两个功能：
(1) 实现矩阵的转置；
(2) 遍历矩 阵，输出矩阵中最大的数及其下标。
#include void transposeMatrix(int matrix[][4], int transpose[][3]){ //定义了函数transposeMatrix来实现矩阵的转置for (int i = 0; i < 3; i++) { for (int j = 0; j < 4; j++){transpose[i][j] = matrix[j][i]; }} } void findMax(int matrix[][4], int *max, int *row, int *col){ //定义了函数indMax来查找矩阵中最大数及其下标*max = matrix[0][0];*row = 0;*col = 0;for (int i = 0; i < 3; i++) { for (int j = 0; j *max) { *max = matrix[i][j]; *row = i; *col = j;} }} } int main(){int matrix[3][4];//定义了一个3x4的整数矩阵matrixint transpose[4][3]; //定义了一个4x3的整数矩阵transposeint max, maxRow, maxCol;printf("Enter the elements of the matrix (3x4):\n");for (int i = 0; i < 3; i++) { for (int j = 0; j < 4; j++){scanf("%d", &matrix[i][j]); //键盘输入矩阵的元素 }}transposeMatrix(matrix, transpose); //调用transposeMatrix函数来进行矩阵的转置findMax(matrix, &max, &maxRow, &maxCol);//调用findMax函数来查找矩阵中最大的数及其下标printf("Matrix transpose:\n");for (int i = 0; i < 4; i++){ for (int j = 0; j < 3; j++){printf("%d ", transpose[i][j]); } printf("\n"); //将转置后的矩阵打印出来。}printf("矩阵中的最大元素: %d\n", max); //将最大数打印出来。printf("最大元素位于第%d行%d列 %d\n", maxRow, maxCol);//将最大数的下标打印出来。return 0; }5 、编写一个结构体类型的程序，定义一个结构体变量 struct student ，
其包含学号，姓名， 三门课的成绩，成绩用数组保存，
要求输入 10 个结构体变量学生的学号、姓名、3 门课程 的成绩，求出总分最高的学生并输出。
#include #define NUM_STUDENTS 10 #define NUM_COURSES 3 struct student//定义了一个结构体类型struct student， {int student_id;//学号student_idchar name[100];//姓名nameint scores[NUM_COURSES]; //成绩scores数组 }; int main(){struct student students[NUM_STUDENTS];//在main函数中创建NUM_STUDENTS个int i, j; struct student类型的数组students用于存储学生信息// 输入学生信息和成绩for(i = 0; i < NUM_STUDENTS; i++){ printf("学生%d的学号：", i+1); //第一重循环中，依次输入每个学生的学号和姓名 scanf("%d", &(students[i].student_id)); printf("学生%d的姓名：", i+1); scanf("%s", students[i].name); printf("学生%d的成绩：\n", i+1); //第二重循环中，依次输入每个学生的三门课程的成绩。 for(j = 0; j < NUM_COURSES; j++){printf("第%d门课成绩：", j+1);scanf("%d", &(students[i].scores[j])); }}// 计算总分最高的学生int max_total_score = 0;int max_total_score_index = 0;for(i = 0; i < NUM_STUDENTS; i++)//第三个循环中，计算每个学生的总分，{int total_score = 0; for(j = 0; j max_total_score){max_total_score = total_score; //并记录总分最高的学生的索引max_total_score_indexmax_total_score_index = i; }}// 利用max_total_score_index输出总分最高的学生信息printf("\n总分最高的学生信息：\n"); printf("学号：%d\n", students[max_total_score_index].student_id); //输出学号printf("姓名：%s\n", students[max_total_score_index].name); //输出姓名printf("总分：%d\n", max_total_score);//输出总分return 0; }6 、斐波那契数列 (Fibonacci sequence) ，又称“黄金分割”数列，
比如这样一个数列：1 ，1， 2 ，3 ，5 ，8 ，13 ，21 ，34 ，55 ，89… …
数列从第 3 项开始，每一项都等于前两项之和。试用 递归函数来实现斐波那契数列的求解。
#include // 递归函数求解斐波那契数列 int fibonacci(int n){if (n <= 1){ return n; //当参数 n 小于等于1时，函数返回 n}return fibonacci(n-1) + fibonacci(n-2); } //否则，函数返回前两项 fibonacci(n-1)和fibonacci(n-2) 的和 int main(){int n;printf("请输入要求解的斐波那契数列的项数：");scanf("%d", &n);//输入要求解的斐波那契数列的项数printf("斐波那契数列前 %d 项为：\n", n);for (int i = 0; i < n; i++) //通过循环利用fibonacci()函数{ 来打印出相应的数列项 printf("%d ", fibonacci(i));}return 0; }