关于概念的问题不做解析，都是死东西，也解析不了
题型
选择题（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<stdio.h>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 TuringC 、John Von Neumann D 、Ken Thompson答案：C`
4 、 计算机直接能识别的是 ( ) 的代码。A 、二进制B 、八进制C 、十进制D 、十六进制答案：A
5 、 计算机存储的都是二进制信息，信息存储的最小单位是 ( ) 。A 、字节 (byte ) B 、二进制位 (bit)C 、字 (word) D 、双字答案：B
6 、若计算机有 32 根地址总线，则其存储器的最大存储容量可达 ( ) 。A 、32MBB 、32GB C 、4GBD 、8GB答案：C解析：存储个数=2^地址线个数1根地址总线是2B，32根就是：2^32=(2^10)^3 * 4=4 * (1024B)^3=4 * 1024MB=4G
7 、下列数据表达的数值与十进制77 不相等的是 ( ) 。 A 、0x4DB 、0x4B C 、0115D 、1001101 答案：B解析：A:这是16进制，0x4D=4*16+13=77B:这是16进制，0x4B=4*16+11=75C:这是8进制，0115=1*8^2+1*8+5=77D:这是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~255 B 、0~65535 C 、-256~255D 、-32768~32767答案：B
12 、下列哪个选项属于 C 语言中的合法字符串常量 ( ) 。A 、how are youB 、”china”C 、/hello/ D 、$abc$答案：B解析：”china”用的是双引号，是字符串
13 、以下哪一个可以作为正确的变量名 ( ) 。A 、3*XB 、 filename C 、forD 、 $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=20<回车>D 、x= 10 y=20<回车> 答案：C解析：按照scanf中" "内定义的格式输入
15 、如有下列程序，输入数据：12345 678<CR>后，程序输出的结果是 ( ) 。#include<stdio.h>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.000000C 、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 、E5 C 、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 、1 B 、1.0C 、2 D 、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.0 B 、2.0C 、5.0 D 、6.0答案：C解析：逗号表达式从左到右执行，取最后一个表达式的值，d++是先用后自增，在表达式结束前不起作用，所以d仍为5
24 、以下程序的运行结果是( ) void main(){int k=4,a=3,b=2,c= 1;printf(“\n%d\n”,k<a?k:c<b?c:a);}A 、4 B 、3 C 、2 D 、 1答案：D解析："k<a"错误，所以计算"c<b?c:a"。"c<b"正确，所以计算"c",由于c=1，所以结果为1
25 、表达式 !(m>0&&n>0) 等价于( )A 、!(m>0)||!(n>0)B 、!m>0||!n>0 C 、!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！= 1C 、E！=0 D 、E= = 1答案：A解析：c语言中除0以外的为非0E!=0，所以!E=0
27 、关于 switch 语句，下列说法中不正确的是 ( ) 。A 、case 语句必须以 break 结束B 、default 分支可以没有C 、switch 后面的表达式可以是整型或字符型D 、case 后面的常量值必须唯一 答案：A
28 、若要求在 if 后一对圆括号中表示 a 不等于 0 的关系,则能正确表示这一关系的表达式为( )A 、 a<>0 B 、 !a C 、 a=0D 、 a答案：D解析：a本来就是非0，不需要其他修饰
29 、以下程序的输出结果是（ ）#include<stdio.h>void 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 、 0 C 、 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 、100C 、 100 200 D 、 输出格式符不够,输出不确定的值答案：A解析：逗号运算符，从左向右，%d先是代表x，之后x又被y顶替
34 、阅读下面的程序 #include<stdio.h>void main(){char ch;scanf("%3c",&ch);printf("%c",ch);}如果从键盘上输入abc<回车>则程序的运行结果是（ ）A、 aB、 bC、 cD、 程序语法出错答案：A解析："char ch"输入的是字符，输入三个字符，输出一个字符，"abc"输出就是"a"
35 、阅读下面的程序 #include<stdio.h> void main(){int i,j;i=010;j=9;printf("%d,%d",i-j,i+j);}则程序的运行结果是（ ）A 、 1, 19 B 、 - 1, 19 C 、 1, 17 D 、 - 1, 17答案：D解析："i=010"是一个八进制的数，所以i=1*8^1+0=8所以i-j=8-9=-1；i+j=8+9=17
36 、阅读下面的程序 #include<stdio.h> 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, 10B 、 9, 11,8, 10C 、 9, 11,9, 10D 、 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 、 20 B 、10 C 、 21 D 、11答案：B解析：逗号运算符从左向右看，首先"a= 10"，定义a 的值然后"a+ 10"虽然值为10+10=20，但是a值本身不变最后"a++"由于自增(++)在后，先用后加，"a++"的值仍然是10，这行代码结束，a的值才为11
38 、阅读下面的程序 #include<stdio.h> void main(){int i,j;scanf("%3d%2d",&i,&j);printf("i=%d,j=%d\n",i,j);}如果从键盘上输入 1234567<回车>,则程序的运行结果是（ ）A 、 i=123,j=4567 B 、 i=1234,j=567C 、 i=1,j=2 D 、 i=123,j=45答案：D解析：i取3位，j取2位，输入1234567，则i=123，j=45
39 、下面程序的输出结果是（ ）#include<stdio.h>void main(){int a=-1, b=4, k;k=(++a<=0)&&(b--<=0);printf("%d,%d,%d\n",k,a,b);}A 、 1, 1,2 B 、 1,0,3 C 、 0, 1,2 D 、 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}};赋值后各元素的值为：1 0 02 0 03 0 0C：定义是两行三列，赋值时却是三行两列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 、如下程序执行后输出为（ ）#include<stdio.h>int 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,4C 、4,2D 、不确定, 不确定答案：B解析：数组里如果没有数当作"0"这组代码的结果是：0 0 00 1 40 2 4
51 、以下程序给数组所有元素输入数据，填入（ ）能完成该功能。#include<stdio.h>int 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<0?0:1B 、5>=1C 、!EOFD 、!NULL答案：C解析：A：4<0，是错的，所以值为后者，为1B：5>=1，是对的，所以值为1C：EOF指文件结束，逻辑不通D：NULL是一个未知值，同时NULL 不等于0，也不是’'(空字符串)，所以!NULL的值为1
54 、有如下函数调用语句 func(rec1,rec2+rec3,(rec4, rec5));该函数调用语句中,含有的实参个数是 ( ) 。A 、3 B 、4C 、5 D 、有语法错误答案：A解析："(rec4, rec5)"是逗号运算符，取最后的为值三个实参分别为：rec1rec2+rec3(rec4, rec5)
55 、以下有关函数的形参和实参的说法中正确的是（ ）A 、实参和与其对应的形参各占用一个字节存储单元B 、只有当实参和与其对应的形参同名时才占用一个存储单元C 、形参是虚拟的，不占用存储单元D 、实参和与其对应的形参各占用独立的存储单元答案：C
56 、能正确表示“当 x 取值在[5，99]和[130 ，180]范围内为真，否则为假”的表达式是（ ）A 、(x>=5)&&(x<=99)&&(x>=130)&&(x<=180)B 、(x>=5)&&(x<=99)||(x>=130)&&(x<=180)C 、(x>=5)||(x<=99)||(x>=130)||(x<=180)D 、(x>=5)&&(x<=99)||(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，则表示 str1 小于 str2。如果返回值 > 0，则表示 str2 小于 str1。如果返回值 = 0，则表示 str1 等于 str2。
62 、设 p1和 p2 是指向同一个字符串的指针变量，c 为字符变量，则以下不能正确执行赋值语句的是（ ）A 、c=*p1+*p2 B 、p2=c-5C 、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. x D. *&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,*pointC. *&point,*point,&i D. &i ,&*point,point答案：D
65 、已知 a 是 int 型变量，则（ ）是对指针变量的正确定义和初始化。A.int *p=a B. int *p=*a C. 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+5 D. *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. getchar D. getc答案：B
74 、将两个字符串 s1 和 s2 连接起来，正确的函数是 ( )A. strcpy(s1,s2) B. strcat(s1,s2) C. strcmp(s1,s2) D. strlen(s1,s2)答案：B解析：A：将s2复制到s1B：连接s1与s2C：比较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 、有以下函数#include<stdio.h>int 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 和 argvC. 当 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 、 16C 、 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<stdio.h>#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 ，7C 、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=6POWER(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<stdio.h>#define P 2#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 ，7C 、6 ，6D 、7 ，7答案：B解析：见T87，完全一样的题目
90 、下面程序的输出结果是（ ）#include<stdio ．h>#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<stdio ．h>#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 、1 B 、10 C 、 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 、10 B 、50C 、51D 、6020 60 60 7020 21 2l 31答案：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 、以下程序的运行结果为（ ）#include<stdio ．h>main(){struct date{int year ，month ，day；}today；printf("％d\n" ，sizeof(struct date))；}A 、6 B 、8 C 、10D 、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 语言程序由若干个函数组成，其中必须有一个_________函数。
答案：main
6 、定义函数时，若缺省函数类型标识符，函数返回值类型为 _________。
答案：int
7 、求 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+i
8 、int i=234,j=567; 函数 printf(“%d%d\n”,i,j) 的输出结果是_________。
答案：234567解析：printf函数中的两个整形之间没有空格，所以输出结果是连贯的
9 、表达式: 10!=9 的值是_________。
答案：1解析：表达式的意思是10不等于9，显然这是正确的，所以值为1
10 、能正确表述判断闰年的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= -264
14 、有以下函数定义：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 类型变量，所以在内存中所占字节数是20
18 、若定义 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]=8
19 、设有如下函数定义：
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 ，应选择的存储类别是_________ 。
答案：static
21 、若有定义 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或8
23 、设 int a=3,b=5,c=7; ，则表达式 a<c&&c>b!=0||c==b+a 的值为________。
答案：1解析：a<c值为1，c>b值为0，所以a<c&&c>b值为0，表达式等价为0!=0||c==b+a0!=0错误，值为0；c==b+a是给c赋值，等价于c=7原表达式等价于0||7，值为1
24 、若已定义 int a,则表达式 a= 10,a+10,a++的值是 _______________。
答案：10解析：a+10没有载体，又因为a++先用后增，所以a++的值为10
25 、对于以下宏定义：#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= 30
26 、对于下面宏定义：
#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=18
27 、ANSI C 标准中定义的用于释放动态空间的函数名是________ ，使用该函数要包含的头文件 是________。
答案：free；malloc.h
28 、定义语句为 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"赋值为26
31 、int x, *p; p=&x; 已知 x 的地址为 0x0028FF1C ，则 p+ 1=____________。
答案：0x0028FF20解析：p= &x= 0x0028FF1C因为x为整型，占4个字节，所以p+ 1= 0x0028FF1C+4=0x0028FF20
32 、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=0x0028FF20
35 、 申请动态内存空间的函数包括____________和____________。
答案：malloc；free
36 、若有 定 义 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列的数，为5
37、有以下语句 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)=10strlen遇到'\0'就停止，所以strlen(s)=7
39 、预处理命令必须以____________开头。
答案：#
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=stul
42、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、下面程序的输出结果是？#include<stdio.h>int 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、写出下面程序的运行结果#include<stdio.h>int 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;}如果从键盘输入 (从下面一行的第一列开始)1<回车>234<回车>则程序的输出结果是？答案：12解析：getchar()是一次读一个字符putchar()只能输出一个字符
3、写出下面程序的运行结果#include<stdio.h>int 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、下面程序的输出结果是？#include<stdio.h>int 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、下面程序的输出结果是？#include<stdio.h>int 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、下面程序的输出结果是 #include<stdio ．h>int main(){int a,b;for(a=1,b=1;a<=100;a++){if(b>=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=8b=-5是干扰部分
7、下面程序的运行结果是？#include <stdio.h>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<stdio ．h> 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<stdio.h>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 <stdio.h>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 yMin(y,z)结果为y，Min(x,Min(y,z)等价于Min(x,y)，结果为y，y=5
12、下面程序的运行结果是？ #include<stdio.h>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 <stdio.h>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 <stdio.h>#define N 4void 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= -3y[1]= a[1][1]-a[1][4-1-1]= 6-7= -1y[2]= a[2][2]-a[2][4-1-2]= 11-10= 1y[3]= a[3][3]-a[3][4-1-3]= 16-13= 3
15、下面程序的运行结果是？#include <stdio.h>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 <string.h>void func(char s[]){int i,j;char c;for(i=0,j=strlen(s)-1; i<j; i++,j--){c=s[i]; s[i]=s[j]; s[j]=c;}}int main(){char str[]="hello";func(str);puts(str);}答案：olleh解析：j= strlen(s)-1= 5-1= 4，根据函数中的for循环，运行2次第一次循环：c= s[i]= s[0]= hs[i]= s[j]=> s[0]= s[4]= os[j]= c=> s[5]= h数组变为oellh第二次循环：c= s[i]= s[1]= es[i]= s[j]=> s[1]= s[3]= ls[j]= c=> s[3]= e数组变为olleh
17、下面程序的输出结果是？#include <stdio.h>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 <stdio.h> 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 <stdio.h>int main(){ char ch[7]="65ab21";int i, s=0;for(i=0; ch[i]>='0' && ch[i]<='9';i+=2) s= 10*s+ch[i]-'0';printf("%d\n",s);}答案：6解析：for(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<stdio.h>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 <stdio.h>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<stdio.h>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<stdio.h>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=5fun(p,q)为无效代码，格式不符，跑不出东西p=&x：p的内存地址指向x所在的内存地址fun(&x,&y)也一样，没用
24、下面程序的运行结果是？ #include<stdio.h> int 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<stdio.h>#include<string.h>int main(){ char ss[10]="1,2,3,4,5";gets(ss);strcat(ss,"6789");printf("%s\n",ss);}答案：ABC6789解析：gets(ss)记录输入的ABCstrcat(ss,"6789")连接"ABC"与"6789"，结果放在"ss"中
26、下面程序的运行结果是？ #include<stdio.h>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<stdio.h> #define P 2#define POWER(x) P*x*xmain(){ 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=6POWER(y+x)= 2*2+1*2*1= 4+2+1= 7
28、下面程序的运行结果是？ #include<stdio.h>#define SUB(X,Y) (X)*Ymain(){ 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 <stdio.h>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 <stdio.h>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 <stdio.h>int main(){int year, month,day;printf("请用标准格式输入一个日期 (YYYY-MM-DD) ：") ;scanf("_____(1)_____",_____(2)_____);printf("_____(3)_____\n",_____(4)_____);return 0;}运行结果：请用标准日期格式输入一个日期 (YYYY-MM-DD) :若用户从键盘输入：- 12- 12<回车>则输出结果为： 年 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 <stdio.h>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 <stdio.h>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)：i<=1000(3)：1/i*sign解析：(1)for从2开始，所以S的初始量应当为1(2)结尾是1/1000，所以for要循环到i>1000才能停下，所以i<=1000是for循环的条件(3)"1/i*sign"使得2~1000变为1/2~1/1000
4、完成下面的程序，求 1 !+3 !+5 !+……+n !的和。#include <stdio.h>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<stdio.h>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、编写递归函数实现求两个整数的最大公约数，主函数读入待求的两个整数并调用公约数函求解，输出结果。#include<stdio.h>int 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 <stdio.h>int main ( ){int a[ 10], min;int i;for (i=0; i<10;i++)_____(1)_____min=a[0]:for (i=2;i<10;_____(2)_____)if(_____(3)_____)min=a[i];printf ("%d", min);return 0;} 答案：(1)：scanf(“%d”,&a[i])(2)：i+=2(3)：min>a[i]解析：(1)使用 for 循环遍历数组，通过 scanf() 函数从键盘输入数组元素的值，并存储在相应的数组位置上(2)使用 for 循环遍历数组，从下标为2的元素开始，每次移动两个位置，即找出下标为偶数的元素(3)使用条件判断语句比较当前元素 a[i] 与 min 的值，如果 a[i] 小于 min，则将 a[i] 赋值给 min
8、以下程序求得二维数组 a 的每行最大值，并存储在数组b 中，请将程序补充完整。#include <stdio.h>void fun (int ar[ ][4], int bar[], int m, int n){int i, j;for(i=0;i<m;i++){_____(1)_____;for(j=1;j<n;j++)if(ar[i][j]>bar[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 找出下标为偶数的元素的最小值，在主函数中输出该值。#include<stdio.h>int 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<stdio.h>#include<stdlib.h>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<stdio.h>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<stdio.h>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<15)(4)：i=k(5)：i>=0(6)：*(b+i)
13、给出矩阵的主对角线之和并找出最大元素#include<stdio.h>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<a[i][j](4)：a,&max,3
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<stdio.h>#include<string.h>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<stdio.h>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<stdio ．h>#include<string．h>#_____(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<_____(5)_____;i++)if(_____(6)_____){printf("name：％8s\n" ，stu[i].name)；printf("rank：％3s\n" ，stu[i].rank)；printf("average：％5. 1f\n" ，stu[i].score)；_____(7)_____；}if(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 <stdio.h>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 <stdio.h>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 <stdio.h>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]; //计算总和sumif (scores[i] < 88) //如果有任何一门课的成绩低于88分，则excellent被置为0{excellent = 0;}}if (sum >= 450) //程序判断总成绩是否大于等于450，{如果是，则将isExcellent置为1，excellent = 1; 表示满足学习优良奖的条件。}if (excellent)//根据isExcellent的值，程序输出对应的提示信息，{告知学生是否符合学习优良奖的条件printf("学生符合学习优良奖的条件\n");} else {printf("学生不符合学习优良奖的条件\n");}return 0;}
4、编写程序:
输入一个 3 ×4 的二维整数矩阵，要求实现两个功能：
(1) 实现矩阵的转置；
(2) 遍历矩 阵，输出矩阵中最大的数及其下标。
#include <stdio.h>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 < 4; j++) {if (matrix[i][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<stdio.h>#define NUM_STUDENTS 10#define NUM_COURSES 3struct 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 < NUM_COURSES; j++) {total_score += students[i].scores[j];}if(total_score > 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 <stdio.h>// 递归函数求解斐波那契数列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;}
南京邮电大学通达学院 高级语言程序设计（C语言） 题库选择 填空 读程序题答案及解析 程序填空答案 编程题答案及代码作用的概括性说明
