关于概念的问题不做解析，都是死东西，也解析不了
选择题（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 Turing
C 、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 、32MB B 、32GB C 、4GB D 、8GB
答案：C
解析：存储个数=2^地址线个数
1根地址总线是2B，32根就是：2^32=(2^10)^3 * 4
=4 * (1024B)^3
=4 * 1024MB
=4G
7 、下列数据表达的数值与十进制77 不相等的是 ( ) 。
A 、0x4D B 、0x4B C 、0115 D 、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 、2 B 、5 C 、4 D 、 1
答案：A
解析：用" "括起来的说明它是一个字符串，任何一个合法字符串都是以'\0'结尾的，
第一个字节是"\x5d"的ASCII码字符，第二个字节是字符串结束符'\0'，
'\0'是系统自动加上去的。
11、C 语言 short 型数据占 2 个字节，则 unsigned short 型数据的取值范围是 ( ) 。
A 、2~255 B 、0~65535 C 、-256~255 D 、-32768~32767
答案：B
12 、下列哪个选项属于 C 语言中的合法字符串常量 ( ) 。
A 、how are you B 、”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=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.000000 B 、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 、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 、 float B 、char C 、 int D 、 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"是正确的，值为非0
C:"a||b+c"是两个非0量通过逻辑或（||）链接，是非0.
然后"非0"与"b-c"这个非0量通过逻辑与（&&）链接，也是非0
D："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.0
C 、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.0
C 、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>0 D 、!(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 、 a<>0 B 、 !a
C 、 a=0 D 、 a
答案：D
解析：a本来就是非0，不需要其他修饰
29 、以下程序的输出结果是（ ）
#include<stdio.h>
void main()
{
int x= 10,y= 10;
printf("%d %d\n",x--,--y);
}
A 、 10 10 B 、 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 、200 B 、100
C 、 100 200 D 、 输出格式符不够,输出不确定的值
答案：A
解析：逗号运算符，从左向右，%d先是代表x，之后x又被y顶替
34 、阅读下面的程序
#include<stdio.h>
void main()
{
char ch;
scanf("%3c",&ch);
printf("%c",ch);
}
如果从键盘上输入
abc<回车>
则程序的运行结果是（ ）
A、 a B、 b
C、 c D、 程序语法出错
答案：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, 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 、 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=567
C 、 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 0
2 0 0
3 0 0
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 、如下程序执行后输出为（ ）
#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,2 B 、2,4
C 、4,2 D 、不确定, 不确定
答案：B
解析：数组里如果没有数当作"0"
这组代码的结果是：
0 0 0
0 1 4
0 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+i D 、&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:1 B 、5>=1
C 、!EOF D 、!NULL
答案：C
解析：A：4<0，是错的，所以值为后者，为1
B：5>=1，是对的，所以值为1
C：EOF指文件结束，逻辑不通
D：NULL是一个未知值，同时NULL 不等于0，也不是’'(空字符串)，所以!NULL的值为1
54 、有如下函数调用语句 func(rec1,rec2+rec3,(rec4, rec5));
该函数调用语句中,含有的实参个数是 ( ) 。
A 、3 B 、4
C 、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<=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-5
C 、p1=p2 D 、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,*point
C. *&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. 输出 a
C. 输出 abcd(有空格) D. 编译不通过
答案：D
解析：这里的s是一个数组包含10个char的首地址，它只可以在初始化的时候用
char s[10]="abcd";
char s[]="abcd";
char *s="abcd";
这三种写法都是对的，但是都是初始化的时候使用
73 、当用户输入的字符串中含有空格时，应使用 （ ）函数读入字符串。
A. scanf B. 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复制到s1
B：连接s1与s2
C：比较s1与s2大小（按ASCII码值大小比较），直到出现不同的字符或遇到"\0"为止
s1=s2，返回0
s1>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 和 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 、 21 B 、 16
C 、 15 D 、 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*x
main()
{
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) ．num D 、 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 ，7
C 、6 ，6 D 、7 ，7
答案：B
解析：见T87，完全一样的题目
90 、下面程序的输出结果是（ ）
#include<stdio ．h>
#define SUB(X ，Y) (X)*Y
main()
{
int a=3 ，b=4；
printf("％d\n" ，SUB(a+b ，b++))；
}
A 、12 B 、15
C 、16 D 、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*y
main()
{
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 、 2 D 、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 、50 C 、51 D 、60
20 60 60 70
20 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 、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 语言程序由若干个函数组成，其中必须有一个_________函数。
答案：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<=100
s+=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= 30
a+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= -132
a+=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= 3
m[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也就是2
2被当做参数传进去后，程序会执行这句 else return fun(k-1)+1;
这就调用了第三次，而参数是2-1也就是1
1被当做参数传进去后，程序会执行这句 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+a
0!=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
=0x0028FF2C
a[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)=10
strlen遇到'\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)=8
t有两个元素，都为结构体。第一个是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=8
j为十进制，所以j=1*10^1=10
k为十六进制，所以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<回车>
则程序的输出结果是？
答案：
1
2
解析：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=8
b=-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 y
Min(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 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 <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= 3
m= i+a+b= 3+4+1= 8
第二次循环：i= i+m+1= 3+8+1 =12
m= 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]= h
s[i]= s[j]=> 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 <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，5
3，5
解析：*p=&x：x的地址付给p，p里存的是一个数值x
所以*p=3，*q=5
fun(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)记录输入的ABC
strcat(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*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<stdio.h>
#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 <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) :
若用户从键盘输入：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 <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 4
struct 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和一个变量m
int m;
printf("输入一个整数m: ");
scanf("%d", &m); //然后从键盘输入一个整数m
int count = fun(array, m); //调用函数fun来输入数组和整数m
printf("小于或等于的质数 %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个元素的数组a
int 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]; //计算总和sum
if (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的整数矩阵matrix
int transpose[4][3]; //定义了一个4x3的整数矩阵transpose
int 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 门课程 的成绩，求出总分最高的学生并输出。文章来源：https://www.toymoban.com/news/detail-767480.html
#include<stdio.h>
#define NUM_STUDENTS 10
#define NUM_COURSES 3
struct student //定义了一个结构体类型struct student，
{
int student_id; //学号student_id
char name[100]; //姓名name
int 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_index
max_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 项开始，每一项都等于前两项之和。试用 递归函数来实现斐波那契数列的求解。文章来源地址https://www.toymoban.com/news/detail-767480.html
#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语言） 题库选择、填空、读程序题答案及解析、程序填空答案、编程题答案及代码作用的概括性说明的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！
