C语言题库(选择)河南工业大学 河工大 c语言期末考试题库
一、选择题
下列叙述中错误的是（ ）。
算法正确的程序最终一定会结束。
算法正确的程序可以有零个输出。
算法正确的程序可以有零个输入。
算法正确的程序对于相同的输入一定有相同的结果。
~B
下列叙述中错误的是（ ）。
C程序必须由一个或一个以上的函数组成。
函数调用可以作为一个独立的语句存在。
若函数有返回值，必须通过return语句返回。
函数形参的值也可以传回给对应的实参。
~D
C语言源程序名的后缀是（ ）。
.exe
.c
.obj
.cp
~B
下列叙述中错误的是（ ）。
用户定义的标示符允许使用关键字。
用户定义的标示符应做到“见名知意”。
用户定义的标示符必须以字母或下划线开头。
用户定义的标示符中大、小写字母代表不同标示。
~A
下列关于函数的叙述正确的是（ ）。
每个函数都可以被其他的函数调用（包含main函数）。
每个函数都可以被单独编译。
每个函数都可以单独运行。
在一个函数内部可以定义另一个函数。
~B
下列不合法的用户标示符是（ ）。
j2_key
_int
4d
_8_
~C
下列定义变量的语句中错误的是（ ）。
int _int;
double int_;
char for;
float us$;
~D
按照C语言规定的用户标示符命名规则，不能出现在标示符中的是（ ）。
大写字母
连字符
数字字符
下划线
~B
对于一个正常运行的C程序，下列叙述正确的是（ ）。
程序的执行总是起止于main函数。
程序的执行总是从第一个函数开始，结束于main函数
程序的执行总是从main函数开始，在最后一个函数结束
程序的执行总是从第一个函数开始，在最后一个函数结束
~A
下列叙述正确的是（ ）。
C语言程序从源程序中第一个函数开始执行
可以在程序中由用户指定一个函数作为主函数，程序将从此开始执行
C语言规定必须用main作为主函数名，程序从此开始执行，在次结束
main可作为用户标示符，可以命名任意一个函数作为主函数
~C
下列叙述正确的是（ ）。
C程序中的注释只能出现在程序的开始位置
C程序书写格式严格，要求一行只能写一个语句
C程序书写格式自由，一行可以写多条语句
用C语言编写的程序只能放在一个程序文件中
~C
下列不合法的数值常量是（ ）。
011
1e1
8.0e0.5
0xabc
~C
可在C程序中用作用户标识符的一组是（ ）。
and _2007
date y-m-d
hi dr.tom
case big1
~A
下列关于long、int和short类型数据占用内存大小的叙述正确的是（ ）。
均占4个字节
根据数据的大小来决定所占内存的字节数
由用户自己定义
由C语言编译系统决定
~D
设变量已正确定义并赋值，以下正确的表达式是（ ）。
x=y*5=x+z
int(15.8%3)
x=y+z+3,++y
x=25%5.0
~C
设
有定义：int k=1;float f=7;则下列选项中错误的表达式是（ ）。
k=k>=k
-k++
k%int(f)
k>=f>=m
~C
表达式3.6-5/2+1.2+5%2的值是（ ）。
4.3
4.8
3.3
3.8
~D
下列叙述中错误的是（ ）。
C程序中的#include和#define行均不是C语句
除逗号运算符外，赋值运算符的优先级最低
C程序中，j++;是赋值语句
C程序中，+、-、*、%是算术运算符，可用于整型数和实型数的运算
~D
下列选项中，当x为大于1的奇数时，值为0的表达式是（ ）。
x%2==1
x/2
x%2!=0
x%2==0
~D
下列叙述中错误的是（ ）。
C语句必须以分号结束
复合语句在语法上被看作一条语句
空语句出现在任何位置都不会影响程序运行
赋值表达式加上分号就构成赋值语句
~C
下列正确定义且赋初值的语句是（ ）。
int n1=n2=10;
char c=32;
float f=f+1.1;
double x=12.3E2.5
~B
若变量已正确定义并赋值，下列合法的语句是（ ）。
x=y==5
x=n%2.5
x+n=i
x=5=1+4
~A
以下定义正确的是（ ）。
int a=b=0;
char A=65+1,b='b';
float a=1,"b=&a,"c=&b;
double a=0.0;b=1.1;
~B
有下列程序：
*main()
*{char a1='M',a2='m';
*printf("%c\n",(a1,a2));
*}
下列叙述正确的是（ ）。
程序输出M
程序输出m
格式说明符不足，编译出错
程序运行时产生出错信息
~B
有下列程序：
*main()
*{int x,y,z;
*x=y=1;
*z=x++,y++,++y;
*printf("%d,%d,%d\n",x,y,z);
*}
*程序运行的结果是（ ）。
2，3，3
2，3，2
2，3，1
2，2，1
~C
设有定义：int k=0;下列选项的4个表达式中与其他3个表达式的值不同的是（ ）。
k++
k=k+1
++k
k+1
~A
在C语言中，以下说法不正确的是（ ）。
在C程序中，整数和实数都能被准确无误的表示出来
在C程序中，任何一个变量名都代表存储器的一个位置
静态变量的生存周期与整个程序的运行期相同
C语言中，任何变量都必须先声明才能进行引用
~A
若有以下定义和语句：
*int a=010,b=0x10,c=10;
*printf("%d,%d,%d\n",a,b,c);
*则输出结果是（ ）。
8，10，10
10，10，10
8，8，10
8，16，10
~D
设C语言中，float类型数据占4个字节，则double类型数据占（ ）个字节。
1
2
8
4
~C
以下正确的实型常量（ ）。
E3.4
-12345
2.2e0.8
4
~B
设int类型的数据长度为2个字节，则unsigned int类型数据的取值范围是（ ）。
0~255
0~65535
-32768~32767
-256~255
~B
设a和b均为int型变量，且a=6,b=11,则能使值为3的表达式是（ ）。
b%(a%4)
b%(a-a%5)
b%a-a%5
(b%a)-(a%4)
~D
已定义变量a为整型，则不能正确表示9
a>9&&a<14
!(a<=9)&&!(a>=14)
~A
以下程序运行的结果是（ ）。
*#include
*main()
*{int a=3,b=4,c=8,d=4,m=1,n=3;
*printf("%d\n",(m=a>b)&&(n=c>d))
*}
0
1
2
3
~A
能正确表示“当x的取值范围
在[1,10]和[100,110]范围内为真，否则为假”的表达式是（ ）。
(x>=1)&&(x<=10)&&(x>=100)&&(x<=110)
(x>=1)||(x<=10)||(x>=100)||(x<=110)
(x>=1)&&(x<=10)||(x>=100)&&(x<=110)
(x>=1)||(x<=10)&&(x>=100)||(x<=110)
~C
若有定义：int a=4,b=5;float x=3.4,y=2.1;则下面表达式的值为（ ）。
*(float)(a+b)/2+(int)x%(int)y
5.5
55
5.500000
55.00000
~C
若a为int型变量，则执行以下语句后，a的值为（ ）。
*a=5;a+=a-=a*a;
25
-40
40
-14
~B
若已定义x和y为整型变量，且x=7,则表达式y=2.3+x/2的值是（ ）。
6
5
5.0
6.0
~B
有以下程序：
*main()
*{int y=1,x=2,z=3;
*printf("%d,%d\n",(++x,y++),z+2);
*}
*执行后的输出结果是（ ）。
3，5
2，5
3，3
1，5
~D
以下程序的输出结果是（ ）。
*main()
*{int a=1,b=2;
*printf("%d,%d\n",--a,++b);
*}
1,2
1,3
0,2
0,3
~D
C语言程序的执行是（ ）。
从程序的主函数开始，到程序的主函数结束
从程序的主函数开始，到程序的最后一个函数结束
从程序的第一个函数开始，到程序的最后一个函数结束
从程序的第一个函数开始，到程序的主函数结束
~A
下面说法正确的是（ ）。
一个C程序可以有多个函数
一个C语言的函数中只允许有一对花括号
C语言一个语句可以写在一行内，也可以写在多行内
在对C程序进行编译时，可以发现注释行中的拼写错误
~C
以下说法正确的是（ ）。
C程序是以函数为基本单位的，整个程序由函数组成
C语言程序的一条语句可以写在不同的行上
C程序的注释行对程序运行不起作用，所以注释应该尽可能少写
C程序的每个语句都以分号结束
~C
以下标示符不是关键字的是（ ）。
break
char
Switch
return
~C
若要求定义具有10个int型元素的一维数组a,则下列定义语句中错误的是（ ）。
#define N 10
*int a[N]
#define n 5
*int a[2*n]
int a[5+5]
int n=10,a[n]
~D
下设有如下程序段
*char s[20]="Beijing",*p;
*p=s;
*则执行p=s；语句后，以下叙述正确的是（ ）。
可以用*p表示s[0]
s数组中元素的个数和p所指字符串长度相等
s和p都是指针变量
数组s中的内容和指针变量p中的内容相同
~A
下列数组定义中错误的是（ ）。
int x[][3]={0};
int x[2][3]={{1,2},{3,4},{5,6}};
int x[][3]={{1,2,3},{4,5,6}};
int x[2][3]={1,2,3,4,5,6};
~B
有以下程序：
*main()
*{int i,t[][3]={9,8,7,6,5,4,3,2,1};
*for(i=0;i<3;i++) printf("%d",t[2-i][i]);
*}
*程序执行后的输出结果是（ ）。
7 5 3
3 5 7
3 6 9
7 5 1
~B
若有定义语句：int a[3][6];,按内存中的存放顺序，a数组的第10元素是（ ）。
a[0][4]
a[1][3]
a[0][3]
a[1][4]
~B
以下错误的定义语句是（ ）。
int x[][3]={{0},{1},{1,2,3}};
int x[4][3]={{1,2,3},{1,2,3},{1,2,3}};
int x[4][]={{1,2,3},{1,2,3},{1,2,3}};
int x[][3]={1,2,3,4};
~C
以下不正确的定义语
句是（ ）。
double x[5]={1.0,2.0,3.0,4.0,5.0};
int y[5]={0,1,2,3,4,5}};
char c[]={'1','2','3','4','5'};
char c2[]={'a','b','c'};
~B
若有以下定义，则正确引用数组元素的是（ ）。
*int a[5],*p=a;
*&a[5]
*a+2
*(p+5)
*(a+2)
~D
若有说明：int a[][3]={0,0};则不正确的叙述是（ ）。
数组a的每个元素的初值都是0
数组a的第一维大小为1
数组a的行数为1
只有元素a[0][0]和a[0][1]初值为0，其余元素得不到初值0
~D
下列二维数组初始化语句中，不正确的是（ ）。
int b[][2]={1,2,3,4,5,6,7};
int b[3][5]={0,0,0};
int b[][4]={{1,2},{3,4,5},{6}};
int b[3][2]={(1,2),(3,4),(5,6)};
~D
有以下程序：
*main()
*{int aa[5][5]={{1,2,3,4},{5,6,1,8},{5,9,10,2},{1,2,5,6}};
*int s=0,i;
*for(i=0;i<4;i++)
*s+=aa[i][2];
printf("%d",s);
*}
*程序运行后的输出结果是（ ）。
26
19
10
20
~B
*以下程序的输出结果是[<4>]。
*#include
*main()
*{
* int a[5]={2,4,6,8,10},*p;
* p=a;p++;
* printf("%d",*p);
*}
*以下程序的输出结果是[<3 5>]。
*#include
*void swap(int *a,int *b)
*{
* int *t ;
* t=a;a=b;b=t;
*}
*main()
*{
* int i=3,j=5,*p=&i,*q=&j;
* swap(p,q);printf("%d %d",*p,*q);
*}
*下面程序段的运行结果是[<68>]。
*char str[]="ABCD",*p=str;
*printf("%d\n",*(p+3));
设已有定义：float x;，则下列对指针变量p进行定义且赋初值的语句中正确的是( )。
float *p=1024;
int *p=(float)x;
float p=&x;
float *p=&x;
~D
设有定义语句int (*f)(int);，则以下叙述正确的是( )。
f是基类型为int的指针变量
f是指向函数的指针变量，该函数具有一个int类型的形参
f是指向int类型一维数组的指针变量
f是函数名，该函数的返回值是其类型为int类型的地址
~B
设有定义：int n1=0,n2,*p=&n2,*q=&n1;，以下赋值语句中与n2=n1;语句等价的是( )。
*p=*q
p=q
*p=&n1;
p=*q
~A
在16位编译系统上，若有定义int a[]={10,20,30},*p=&a;，当执行p++;后，下列说法错误的是( )。
p向高地址移了一个字节
p向高地址移了一个存储单元
p向高地址移了两个字节
p与n+1等价
~A
若有定义语句：int k[2][3],*pk[3];，则下列语句中正确的是( )。
pk=k;
pk[0]=&k[1][2];
pk=k[0];
pk[1]=k;
~B
若有定义：char(*p)[6];则标识符p( )。
是一个指向字符型变量的指针
是一个指针数组名
是一个指针变量，它指向一个含有6个字符型元素的一维数组
定义不合法
~C
下面程序段的运行结果是( )。
#include
void main()
{ char str[]="abc",*p=str;
printf("%d\n",*(p+3));
}
67
0
字符'C'的地址
字符'C'
~B
若有以下定义，则对a数组元素的正确引用是( )。
int a[5],*p=a;
*&a[5]
*a+1
*(p+5)
*(a+2)
~D
若变量a和b已定义为int类型并赋值21和55，要求用printf函数以a=21,b=55的形式输出，请写出完整的输出语
句[
~~~2
*执行下列程序时，输入1234567
*#include
*main()
*{ int a=1,b;
* scanf("%2d%2d",&a,&b);printf("%d%d\n",a,b);
*}
数字字符0的ASC||值为48，运行下列程序的输出结果是( )。
main()
{ char a='1',b='2';
printf("%c,",b++);
printf("%d\n",b-a);
}
3,2
50,2
2,2
2,50
~C
下列不合法的字符常量是( )。
'\018'
'\"'
'\\'
'\xcc'
~A
下列能正确定义字符串的语句是( )。
char str[]={'\064'};
char str="kx43";
char str='';
char str[]="\0";
~D
下列合法的字符型常量是( )。
'\x13'
'\081'
'65'
"\n"
~A
已知大写字母A的ASC||码是65，小写字母a的ASC||码是97。下列不能将变量c中的大字字母转换为对应小写字母的语句是( )。
c=(c-'A')%26+'a'
c=c+32
c=c-'A'+'a'
c=('A'+C)%26-'a'
~D
已知字符'A'的ASC||码值是65，字符变量c1的值是'A',c2的值是'D'。执行语句printf("%d,%d",c1,c2-2);后，输出结果是( )。
A,B
A,68
65,66
65,68
~C
下列正确的字符串常量是( )。
"\\\"
'abc'
Olympic Games
""
~D
要求通过while循环不断读入字符，当读入字母N时结束循环。若变量已正确定义，下列正确的程序段是( )。
while((ch=getchar())!='N') printf("%c",ch);
while(ch=getchar()!='N') printf("%c",ch);
while(ch=getchar()=='N') printf("%c",ch);
while((ch=getchar())=='N') printf("%c",ch);
~A
有以下程序段( )。
char ch;int k;
ch='a';k=12;
printf("%c,%d,",ch,ch,k);
printf("k=%d\n",k);
已知字符a的ASC||十进制代码为97，则执行上述程序段后输出结果是
因变量类型与格式描述符的类型不匹配输出无定值
输出项与格式描述符个数不符，输出为零值或不定值
a,97,12k=12
a,97,k=12
~D
有定义语句：int b;char c[10];，则正确的输入语句是( )。
scanf("%d%s",&b,&c);
scanf("%d%s",&b,c);
scanf("%d%s",b,c);
scanf("%d%s",b,&c);
~B
设有定义：int a; float b;，执行scanf("%2d%f",&a,&b);语句时，若从键盘输入876543.0
876和543.000000
87和6.000000
87和543.000000
76和543.000000
~B
设变量均已正确定义，若要通过scanf("%d%c%d%c",&a1,&c1,&a2,&c2);语句为变量a1和a2赋数值10和20，为变量c1和c2赋字符X和Y。下面的输入形式中正确的是( )(注：□代表空格字符)。
10□X□20□Y
10□X20□Y
10□X
10X
~A
有下列程序段：
int j; float y;char name[50];
scanf("%2d%f%s",&j,&y,name);
当执行上述程序段，从键盘上输入55566 7777abc后，y的值为( )。
55566.0
566.0
7777.0
566777.0
~B
以下选项中不是字符常量的是( )。
'\v'
'\x2a'
'a'
"\0"
~D
以下选项中非法的字符常量是( )。
'\\'
'\020"
'\xAA'
'0'
~B
在执行完下面的C语句段之后，则B的值是( )。
char a='A';
int b;
B=((34&&56)&&(a<'b'));
0
1
TRUE
FALSE
~B
若变量已正确定义，以下正确的程序段是( )。
while(ch=getchar()=='\N') putchar(ch);
while((ch=getchar())=='\n')putchar(ch);
while((ch=getchar())!='\N')putchar(ch);
while((ch=getchar())!='\n')putchar(ch);
~D
若变量已正确定义，下面程序段的输出结果是( )。
#include
main()
{float x=1.236547;
printf("%f\n",(int)(x*1000+0.5)/(float)1000);
}
1.237000
输出格式说明与输出项不匹配，输出无定值
1.236000
1.24
~A
设已定义x为double类型变量：
#include
main()
{ float x=323.82631;
printf("%.2e\n",x);
}
则以上语句( )。
输出格式描述符的域宽不够，不能输出
输出为32.38e+01
输出为3.24e+002
输出为3.24e2
~C
若有以下定义和语句：
int u=011,v=0x11,w=11;
printf("%o,%x,%d\n",u,v,w);
则输出结果是( )。
9,17,11
9,11,11
11,11,11
11,17,11
~C
语句"printf("a\bhow\'are\'y\\\bou\n");"的输出结果是( )。
a\bhow\'are\'y\\bou
a\bhow\'are\'y\bou
how'are'you
ahow'are'y\bou
~C
若变量已正确定义，要求通过scanf("%c%d%c%d",&c1,&a,&c2,&b)语句给变量a和b赋数值32和45，给变量c1和c2赋字符A和B；以下选项中数据从第1列开始输入，正确的输入形式是( )。
A32<回车>B45<回车>
A45<回车>B32<回车>
A32B45<回车>
A 32 B 45<回车>
~D
若有"double a;"，则正确的输入语句是( )。
scanf("%lf",a);
scanf("%f",&a);
scanf("%lf",&a);
scanf("%le",&a);
~D
已知i、j、k为int型变量，若要从键盘输入2,3,4<回车>，使i、j、k的值分别为2、3、4，以下正确的输入语句是( )。
scanf("%3d,%3d,%3d",&i,&j,&k);
scanf("%d,%d,%d",&i,&j,&k);
scanf("%d%d%d",&i,&j,&k);
scanf("i=%d,j=%d,k=%d",&i,&j,&k);
~B
下列程序中，fun()函数的功能是计算x^2-2x+6，主函数中将调用fun() 函数计算：
y1=(x+8)^2-2(x+8)+6
y2=sin^2(x)-2sin(x)+6
请填空。
#include "math.h"
double fun(double x) {return(x*x-2*x+6);}
main()
{ double x,y1,y2;
printf("Enter x:");
scanf("%lf",&x);
y1=fun([
y2=fun([
printf("y1=%lf,y2=%lf\n",y1,y2);
}
有下列程序：
int sub(int n) {return (n/10+n%10);}
main()
{ int x,y;
scanf("%d",&x);
y=sub(sub(sub(x)));
printf("%d\n",y);
}
若运行时输入：1234
下列运算符中优先级最高的运算符是()。
!
%
-=
&&
~A
下列运算符中优先级最低的运算符是()。
||
!=
<=
+
~A
为表示关系x≥y≥z,应使用的C语言表达式是()。
(x>=y)&&(y>=z)
(x>=y)AND(y>=z)
(x>=y>=z)
(x>=y)&(y>=z)
~A
设a、b和c都是int型变量，且a=3，b=4，c=5；则以下的表达式中，值为0的表达式是()。
a&&b
a<=b
a||b+c&&b-c
!(a
若有int s[4]={1,2,3,4};则s[s[0]+2*s[2]-s[3]]的值是()。
1
2
3
4
~D
对数组的描述正确的是()。
数组一旦定义去大小是固定的，但数组元素的类型可以不同
数组一旦定义去大小是
固定的，但数组元素的类型必须相同
数组一旦定义去大小是可变的，但数组元素的类型可以不同
数组一旦定义去大小是可变的，但数组元素的类型必须相同
~B
对字符串"Boy"进行完整赋值的操作是()
char s[3]={'B','o','y'}
char s[]="Boy"
char s[3]={"Boy"}
char s[3];s="Boy"
~B
在c语言中引用数组元素时，其数组下标的数组类型允许是()
整型常量
整型表达式
整型常量或整型表达式
任何类型的表达式
~C
对以下说明语句的正确理解是()
*int a[10]={6,7,8,9,10}
将5个初值依次赋给a[1]至a[5]
将5个初值依次赋给a[0]至a[4]
将5个初值依次赋给a[6]至a[10]
因为数组长度与初值的个数不相同，所以此语句不正确
~B
以下程序段给数组所有元素输入数据，应在下划线处填入的是()
*main()
*{
*int a[10],i=0;
*while(i<10) scanf("%d",_______);
*:
*:
*}
a+(i++)
&a(i+1)
a+i
&a[++i]
~D
以下程序的输出结果是()
*main()
*{
* int a[]={2,4,6,8},y=1,x,*p;
*p=&a[1];
*for(x=0;x<3;x++) y+=*(p+x);
*printf("%d\n",y);
*}
17
18
19
20
~C
下述函数定义形式正确的是()
int f(int x;int y)
int f(int x, y)
int f(int x,int y)
int f(x,y:y)
~C
关于函数参数，说法正确的是()
实参与其对应的形参各自占用独立的内存单元
实参与其对应的形参共同占用一个内存单元
只有当实参和形参同名时才占用同一个内存单元
形参是虚拟的，不占用内存单元
~A
用数组名作为函数的实参时，传递给形参的是()
数组的首地址
数组的第一个元素
数组中的全部元素
数组的元素个数
~A
复合语句中定义的变量的作用范围是()
整个源文件
整个函数
整个程序
所定义的复合语句
~D
一个函数的返回值由()确定
return语句中的表达式
调用函数的类型
系统默认的类型
被调用函数的类型
~D
以下说法正确的是()
C语言程序总是从第一个定义的函数开始执行
在C语言程序设计中，要调用的函数必须在main函数中定义
C语言程序总是从main函数开始执行
C语言程序中的main函数必须放在程序的开始部分
~C
以下函数的类型是()
*fff(float x)
*{
*printf("",x*x);
*}
与参数x的类型相同
void类型
int类型
无法确定
~C
以下程序的输出结果是()
*fun(int a,int b)
*{int c;
*c=a+b;
*retutn c;
*}
*main()
*{int x=6,y=7,z=8,r;
*r=func((x--,y++,x+y),z--);
*printf("%d\n",r);
*}
11
20
21
31
~C
当说明一个结构体变量时，系统分配给它的内存是()
各成员所需内存总量的总和
结构中第一个成员所需内存量
成员中占内存量最大者所需的容量
结构中最后一个成员所需内存量
~A
设有以下说明语句：
*struct stu
*{int a;
* float b;
*}stutype;
*则下面叙述不正确的是()
strut是结构体类型的关键字
strut stu是用户定义的结构
体类型
stutype是用户定义的结构体类型名
a和b都是结构体成员名
~C
C语言结构体类型变量在执行期间()
所有成员一直驻留在内存中
只有一个成员驻留在内存中
部分成员驻留在内存中
没有成员驻留在内存中
~A
若想对文本文件只进行读操作，打开此文件的方式为()
"r"
"W"
"a"
"r+"
~A
如果要打开C盘file文件夹下的abc.dat文件，fopen函数中第一个参数应为()
c:file\abc.dat
c:\file\abc.dat
"c:\file\abc.dat"
"c:\\file\\abc.dat"
~D
用fopen函数打开文件，操作完毕后用()函数关闭它
fopen
open
fclose
close
~C
以下可作为函数fopen中第一个参数的正确格式是()
c:user\test.txt
c:\user\test.txt
"c:\user\test.txt"
"c:\\user\\test.txt"
~D
若执行fopen函数时发生错误，则函数的返回值是()
地址值
0
1
EOF
~B
若要用fopen函数打开一个新的二进制文件，该文件要既能读也能写，则文件方式字符串应是()
"ab++"
"wb+"
"rb+"
"ab"
~B
若以"a+"方式打开一个已存在的文件，则以下叙述正确的是()
文件打开时，原有文件内容不被删除，位置指针移到文件末尾，可作添加和读操作
文件打开时，原有文件内容不被删除，位置指针移到文件开头，可作重写和读操作
文件打开时，原有文件内容不被删除，只可作写操作
以上各种说法皆不正确
~A
在C语言中，函数返回值的类型最终取决于（）。
函数定义时在函数首部所说明的函数类型
return语句中表达式值的类型
调用函数时主调函数所传递的实参类型
函数定义时形参的类型
~A
若各选项中所用变量已正确定义，fun()函数中通过return语句返回一个函数值，下列选项中错误的程序是（）。
main()
{x=fun(2,10);}
float fun(int a,int b){}
float fun(int a,int b){}
main()
{x=fun(i,j);}
float fun(int,int);
main()
{x=fun(2,10);}
float fun(int a,int b) {}
main()
{float fun(int i,int j);
x=fun(i,j);}
float fun(int a,int b){}
~A
若函数调用时的实参为变量时，下列关于函数形参和实参的叙述中正确的是（）。
函数的实参和其对应的形参共占同一个存储单元
形参只是形式上的存在，不占用具体的存储单元
同名的实参和形参占同一个存储单元
函数的形参和实参分别占用不同的存储单元
~D
在一个C源程序文件中所定义的全局变量，其作用域为（）。
所在文件的全部范围
所在程序的全部范围
所在函数的全部范围
由具体定义位置和extern说明来决定范围
~D
C语言规定，函数返回值的类型是（）。
由调用该函数时的主调函数类型所决定
由return语句中的表达式类型所决定
由调用该函数时系统临时决定
由定义该函数时所指定的数值类型决定
~D
以下叙述中，错误的是（）。
在同一个C程序文件
中，不同函数中可以使用名字相同的变量
在main()函数体内定义的变量是全局变量
形参是局部变量，函数调用完成即失去意义
若同一文件中全局和局部变量同名，则全局变量在局部变量作用范围内不起作用
~B
以下函数值的类型是（）。
fun(double x)
{ float y;
y=3*x-4;
return y;
}
int
不确定
void
float
~A
有以下程序：
int fl(double a)
{return a*a;}
int f2(int x,int y)
{ double a,b;
a=f1(x);
b=f1(y);
return a+b;
}
main()
{ double w;
w=f2(2.1,4.0);
.
.
}
变量w的值是（）。
20.21
20
20.0
0.0
~C
调用函数时，当实参和形参都是简单变量时，它们之间数据传递的过程是（）。
实参将其值传递给形参，调用结束时形参再将其值回传给实参
实参将其地址传递给形参，调用结束时形参再将其地址回传给实参
实参将其地址传递给形参，并释放原先占用的存储单元
实参将其值传递给形参，调用结束时形参并不将其值回传给实参
~D
下面说法不正确的是（）。
调用函数时，实参可以是表达式
调用函数时，实参和形参可以共用内存单元
调用函数时，将实参的值复制给形参，使实参变量和形参变量在数值上相等
调用函数时，实参与形参的类型必须一致
~B
下面函数调用语句含有实参的个数为（）。
func((exp1,exp2),(exp3,exp4,exp5));
1
2
3
5
~B
在C语言中，函数调用时（）。
实参和形参各占独立的存储单元
实参和形参共用存储单元
由系统自动确定实参和形参是否共用存储单元
由用户指定实参和形参是否共用存储单元
~A
C语言规定，程序中各函数之间（）。
既允许直接递归调用也允许间接递归调用
既不允许直接递归调用也不允许间接递归调用
允许直接递归调用不允许间接递归调用
不允许直接递归调用允许间接递归调用
~A
下列能正确定义一维数组的选项是（）。
int a[5]={0,1,2,3,4,5};
char a[]={0,1,2,3,4,5};
char a={'A','B','C'};
int a[5]="0123";
~B
下列叙述中错误的是（）。
对于double类型数组，不可以直接用数组名对数组进行整体输入或输出
数组名代表的是数组所占存储区的首地址，其值不可改变
在程序执行中，数组元素的下标超出所定义的下标范围时，系统将给出“下标越界”的出错信息
可以通过赋初值的方式确定数组元素的个数
~C
有下列程序：
#include
main()
{ char p[]={'a','b','c'},q[10]={'a','b','c'};
printf("%d%d\n",strlen(p),strlen(q));
}
下列叙述中正确的是（）。
在给p和q数组赋初值时，系统会自动添加字符串结束符，故输出的长度都为3
由于p数组中没有字符串结束符，长度不能确定，但q数组中字符串长度为3
由于q数组中没有字符串结束符，长度
不能确定，但p数组中字符串长度为3
由于p和q数组中都没有字符串结束符，故长度都不能确定
~A
若要求从键盘读入含有空格字符的字符串，应使用函数（）。
getc()
gets()
getchar()
scanf()
~B
当用户要求输入的字符串中含有空格时，应使用的输入函数是（）。
scanf()
getchar()
gets()
getc()
~C
当有定义语句：char s[10];,若要从终端给s输入5个字符，错误的输入语句是（）。
gets(&s[0]);
scanf("%s",s+1);
gets(s);
scanf("%s",s[1]);
~D
当以下叙述中错误的是（）。
gets函数用于从终端读入字符串
getchar函数用于从磁盘文件读入字符
fputs函数用于把字符串输出到文件
fwrite函数用于以二进制形式输出数据到文件
~B
下列关于字符串的叙述中正确的是（）。
C语言中有字符串类型的常量和变量
两个字符串中的字符个数相同时才能进行字符串大小的比较
可以用关系运算符对字符串的大小进行比较
空串一定比空格打头的字符串小
~D
下面能正确进行字符串赋值的是（）。
char s[5]={"ABCDE"};
char s[5]={'A','B','C','D','E'};
char*s; s="ABCDE";
char*s;printf("%s",s);
~C
字符串"\\\"ABCDEF\"\\"的长度是（）。
15
10
7
8
~B
下面各语句行中，能正确进行赋值字符串操作的是（）。
char s[5]={'a','b','c','d','e'};
char *s;gets(s);
char *s;*s="ABCDEF";
char s[5];scanf("%s",&s);
~B
设已执行预编译命令#include
char s[]="abcdefg";
printf("%d\n",strlen(s));
7
8
9
10
~A
若已包括头文件
strcpy(s1,s2);
strcpy(s1,"ABCDE");
s1="ABCDE";
for(i=0;i<6;i++)
s1[i]=s2[i];
~C
下列程序运行后的输出结果是[<10 20 0>]。
main()
{int a,b,c;
a=10;b=20;c=(a%b<1)||(a/b>1);
printf("%d %d %d\n",a,b,c);
}
下列程序用于判断a、b、c能否构成三角形，若能输出YES，否则输出NO。请填空。
main()
{float a,b,c;
scanf("&f&f&f",&a,&b,&c);
if([<(a+b>c)&&(a+c>b)&&(b+c>a)>]) printf("YES\n");
else printf("NO");
}
已有定义：char c='';int a=1,b;执行b!=c&&a;后b的值为[<0>]。
下列程序的输出结果是[<1>]。
main()
{int a=1,b=2,c=3;
if(c=a) printf("%d\n",c);
else printf("%d\n",b);
}
}
下列程序的输出结果是[<1>]。
main()
{int x,a=1,b=2,c=3,d=4;
x=(a
printf("%d\n",x);
}
下列程序的输出结果是[<0235>]
main()
{int k=5,n=0;
do
{switch(k)
{case 1: case 3:n+=1;k--;break;
default:n=0;k--;
case 2: case 4:n+=2;k--;break;
}
printf("%d",n);
}while(k>0&&n<5);
}
下列程序的输出结果是[<25>]
main()
{int i;
for(i=1;i<=10;i++)
{ if((i*i>=20)&&(i*i<=100))
break;
}
printf("%d\n",i*i);
}
下列程序的输出结果是[<2,2,0>]
main()
{int a=-5,b=1,c
=1;
int x=0,y=2,z=0;
if(c>0) x=x+y;
if (a<=0)
{ if(b>0)
if(c<=0) y=x-y;
}
else if (c>0) y=x-y;
else z=y;
printf("%d,&d,&d\n",x,y,z);
}
有下列程序段，且变量已正确定义和赋值：
for(s=1.0,k=1;k<=n;k++)s=s+1.0/(k*(k+1));
printf("s=%f\n\n"，s);
请填空，使下列程序段的功能与之完全相同。
s=1.0;k=1;
while([
printf("s=%f\n\n"，s);
下列程序的功能是：将输入的正整数按逆序输出。例如，如输入135则输出531，请填空。
main()
{int n,s;
scanf("%d",&n);
do
{s=n%10;printf("%d",s);[
while (n!=0);
}
下列程序的功能是计算：s=1+12+123+1234+12345.请填空。
main()
{int t=0,s=0,i;
for(i=1;i<=5;i++)
{t=i+[
printf("%d\n",s);
}
下列程序的运行结果是[<32>]。
main()
{int i=0,a=0;
while(i<20)
{for(;;)
{if(i%10==0)break;
else i--;
}
i+=11;
a+=i;
}
printf("%d\n",a);
}
在下列给出的表达式中，与while(E)中的(E)不等价的表达式是（）。
(!E==0)
(E>0||E<0)
(E==0)
(E!=0)
~B
已知字母A的ASCII值为65，若变量kk为char型，以下不能正确判断出kk的值为大写字母的表达式是（）。
kk>='A'&&kk<='Z'
!(kk>='A'||kk<='Z')
(kk+32)>='a'&&(kk+32)<='z'
isalpha(kk)&&(kk<91)
~B
设有定义：int a=2,b=3,c=4;,则下列选项中值为0的表达式是（）。
(!a==1)&&(!b==0)
(a
a||(b+b)&&(c-a)
~A
下列关于逻辑运算符两侧运算对象的叙述中正确的是（）。
只能是整数0或1
只能是整数0或非0
可以是结构体类型的数据
可以是任意合法的表达式
~D
当变量c的值不为2、4、6时，值也为真的表达式是（）。
(c==2)||(c==4)||(c==6)
(c>=2&&c<=6)||(c!=3)||(c!=5)
(c>=2&&c<=6)&&!(c%2)
(c>=2&&c<=6)&&(c%2!=1)
~C
在嵌套使用if语句时，C语言规定else总是（）。
和之前与其具有相同缩进位置的if配对
和之前与其最近的if配对
和之前与其最近的且不带else的if配对
和之前的第一个if配对
~C
设变量x和y均已正确定义并赋值。下列if语句中，在编译时将产生错误信息的是（）。
if(x++) ;
if(x>y&&y!=0)
if (x>0) x-- else y++
if (y<0){;} else x++;
~C
若变量已正确定义，有以下程序段：
*int a=3,b=5,c=7;
*if(a>b) a=b;c=a;
*if(c!=a) c=b;
*printf("%d,%d,%d\n",a,b,c);
*其输出结果是（）。
程序段有语法错误
3,5,3
3,5,5
3,5,7
~B
下列叙述中正确的是（）。
break只能用于 switch语句
switch语句中必须使用default
break必须与switch语句中的case配对使用
在switch中，不一定使用break
~D
若变量已正确定义，以下表达式错误的是（）。
a/b+c
a%(5.0)
a=1/3*(x=y=10,x*2)
a=b=c
~B
下列程序运行后的输出结果是（）。
*main()
*{int a=4,b=3,c=2,d=1;
*printf("%d",a
1
3
2
4
~A
若a=3,b=4,c=5,d=6,则条件表达式a
3
2
1
~B
执
行下面程序中的输出语句后，a的值是（）。
*main()
*{int a;
*printf("%d\n",(a=2*3,a*5,a+7));
*}
17
37
6
13
~C
当a=1,b=2,c=3,d=4时，执行下面程序段后，x的值是（）。
*if(a
* if(a
*else x=6;
*else x=7;
1
2
3
6
~A
有下列程序：
*main()
*{int k=5;
*while(--k) printf("%d",k-=3);
*printf("\n");
*}
*执行后的输出结果是（）。
1
2
4
死循环
~A
有下列程序段：
int n,t=1,s=0;
scanf("%d",&n);
do {s=s+t;t=t-2;}while(t!=n);
为使此程序不陷入死循环，从键盘输入的程序应该是（）。
任意正奇数
任意负偶数
任意正偶数
任意负奇数
~D
若变量已正确定义，有下列程序段：
*i=0
*do printf("%d,",i);while(i++);
*printf("%d\n",i);
*其输出结果是（）。
0,0
0,1
1,1
程序进入无限循环
~B
有下列程序:
*main()
*{int i,j,m=55;
*for(i=1;i<=3;i++)
*for(j=3;j<=i;j++) m=m%j;
*printf("%d\n",m);
*程序的运行结果是（）。
0
1
2
3
~B
下列程序的运行结果是（）。
*main()
*{int a=1,b;
*for(b=1;b<=10;b++)
*{if(a>=8) break;
*if(a%2==1)
*{a+=5;continue;}
*a=3;
*}
*printf("%d\n",b);}
3
4
5
6
~B
下列叙述中正确的是（）。
break语句只能用于switch语句中
continue的作用是使程序的执行流程跳出包含它的所有循环
break语句只能用于循环体内和switch语句中
在循环体内使用break语句和continue语句的作用相同
~C
设有程序段：
*int k=12;
*while (k=1)k=k-1;
*则下面描述中正确的是（）。
while循环执行10次
循环是无限循环
循环体语句一次也不执行
循环体语句执行一次
~C
下列程序段的运行结果是（）。
*x=y=0;
*while(x<25)
*{y++;
*x+=++y;
*}
*printf("%d,%d",y,x);
30,9
9,30
3,1
10,30
~D
while和 do while循环的主要区别是（）。
do while循环的循环体不能是复合语句
do while循环允许从循环体外转到循环体内
while循环的循环体至少被执行一次
do while循环的循环体至少被执行一次
~D
下面的for语句的循环次数是（）。
*for(x=1,y=0;(y!=19&&(x<6);x++);
无限循环
循环次数不定
最多执行6次
最多执行5次
~D
下面结论中错误的是（）。
可以用do while语句实现的循环一定可以用while语句实现
可以用for语句实现的循环一定可以用while语句实现
可以用while语句实现的循环一定可以用for语句实现
do while语句和while语句的区别仅是while出现的位置不同
~D
若i,j已定义成int型，则以下程序段中内循环体的总执行次数是（）。
*for(i=6;i>0;i--)
*for(j=0;j<4;j++){...}
20
24
25
30
~B
以下循环体的执行次数是（）。
*main()
*{int i,j;
*for(i=0,j=1;i
3
2
1
0
~C
下列叙述中正确的是（）。
只能在循环体内和switch语句内使用break语句
continu
e的作用是结束整个循环的执行
在循环体内使用break和continue的作用相同
从多层循环嵌套中退出时，只能使用goto语句
~A
若已知：a=1，b=2，则表达式：!(a
若s是int型变量，且s=8，则s%3+(s+1)%3表达式的值为[<2>]。
若x和n均是int型变量，且x=12，n=5，则执行y=x%=(n%=2)表达式后y的值为[<0>]。
以下说法中正确的是（ ）。
C语言程序的执行都是从程序的第一个函数开始
在C语言程序中，要调用的函数必须在main()函数中声明
任何C语言程序的执行都是从main()函数开始
C语言程序中的main()函数必须放在程序的最前面
~C
以下合法的标识符是（ ）。
123
#256
a.55
abhj1_2_3
~D
以下程序的运行结果是（ ）。
#include
*main()
*{ int a=3,b=4,c=8,d=4,m=1,n=3;
* printf("%d\n",(m=a>b)&&(n=c>d));
*}
0
1
2
3
~A
有定义语句：int b;char c[10];，则正确的输入语句是（ ）。
scanf("%d%s",&b,&c);
scanf("%d%s",&b,c);
scanf("%d%s",b,c);
scanf("%d%s",b,&c);
~B
有下列程序：
*main()
*{ int m,n,p;
* scanf("m=%dn=%dp=%d",&m,&n,&p);
* printf("%d%d%d",m,n,p);
*}
*若想从键盘上输入数据，使变量m的值为123，n的值为456，p的值为789，则正确的输入是（ ）。
m=123 n=456 p=789
m=123 n=456 p=789
m=123,n=456,p=789
123 456 789
~A
要求当A的值为奇数时，表达式的值为“假”，A的值为偶数时，表达式的值为“真”。则以下能满足要求的是（ ）。
A%2==1
!(A%2==0)
!(A%2)
A%2
~C
当把四个表达式用作if语句的控制表达式时，有一个选项与其他三个选项含义不同，这个选项是（ ）。
k%2
k%2==1
(k%2)!=0
!k%2==1
~A
下列不能正确计算代数式(1/3)sin2(1/2)值的C语言表达式是（ ）。
1/3*sin(1/2)*sin(1/2)
sin(0.5)*sin(0.5)/3
pow(sin(0.5),2)/3
1/3.0*pow(sin(1.0/2),2)
~A
在printf的格式字符中，e格式字符的作用是（ ）。
以十六进制无符号形式输出整数
以带符号的十进制形式输出整数
以指数形式输出实数
以字符形式输出，且只输出一个字符
~C
若要从键盘读入含有空格字符的字符串，应使用函数（ ）。
getc()
gets()
getchar()
scanf()
~B
当a=4，b=5，c=7，d=6时，执行下面一段程序：
*if(a
* if(a
* else x=4;
*else x=5;
*执行后，x的值为（ ）。
1
2
3
4
~B
下面4个关于C语言的结论中错误的是（ ）。
可以用do...while语句实现的循环一定可以用while语句实现
可以用for语句实现的循环一定可以用while语句实现
可以用while语句实现的循环一定可以用for语句实现
do...while语句与while语句的区别是关键字“while”出现的位置不同
~D
关于字符常量，以下叙述正确的是（ ）。
空格不是一个字符常量
字符常
量能包含大于一个的字符
单引号中的大写字母和小写字母代表的是相同的字符常量
所有的字符常量都可以作为整型量来处理
~D
有以下函数定义：
*int fun(double a,double b)
*{return a*b;}
*若以下选项中所有变量都已经定义并赋值，错误的函数调用是（ ）。
if(fun(x,y)){......}
z=fun(fun(x,y),fun(x,y));
z=fun(fun(x,y)x,y);
fun(x,y);
~C
执行以下语句段后，xy的值是（ ）。
*int *pt,xy;
*xy=200;
*pt=&xy;
*xy=*pt+30;
200
170
260
230
~D
下面各语句行中，能正确进行赋值字符串操作的是（ ）。
char s[5]={'a','b','c','d','e'};
char *s;gets(s);
char *s;s="ABCDEF";
char s[5];scanf("%s",&s);
~B
以下有关宏的不正确的是（ ）。
宏名无类型
宏定义不做语法检查
宏名必须用大写字母表示
双引号中出现的宏名不进行替换
~C
下面说法正确的是（ ）。
一个C程序可以有多个主函数
一个C语言的函数中只允许有一对花括号
C程序的书写格式是自由的，一个语句可以写在一行上，也可以写在多行内
在对C程序进行编译时，可以发现注释行中的拼写错误
~C
若a为int型变量，则执行以下语句后，a的值为（ ）。
*a=5;
*a+=a-=a*a;
25
-40
40
-14
~B
能正确表示逻辑关系“a>=5或a<=0”的C语言表达式是（ ）。
a>=5 or a<=0
a>=0 || a<=5
a>=5 && a<=0
a>=5 || a<=0
~D
以下能正确表示x在-5到5（含-5和5）内，值为“真”的表达式是（ ）。
(x>=-5)&&(x<=5)
!(x>=-5||x<=5)
x<5 && x>-5
(x<-5)||(x<5)
~A
以下关于运算符优先顺序描述中正确的是（ ）。
算术运算符<关系运算符<赋值运算符<逻辑运算符
赋值运算符<逻辑运算符<关系运算符<算术运算符
逻辑运算符<关系运算符<算术运算符<赋值运算符
关系运算符<算术运算符<赋值运算符<逻辑运算符
~B
以下合法的C语言赋值语句是（ ）。
a=b=1
a=int a+b
a=2,b=3
i++;
~D
若i、j已定义成int型，则以下程序段中内循环体的总执行次数是（ ）。
*for(i=6;i>0;i--)
*for(j=0;j<4;j++){...}
20
24
25
30
~B
以下选项中非法的字符常量是（ ）。
'\\'
'\0201'
'\xAA'
'0'
~B
如果在一个函数的复合语句中定义了一个变量，则该变量（ ）。
在该复合语句中有效，在该复合语句外无效
在该函数内都有效
在本程序的原文件范围内均有效
此定义方法错误，其变量为非法变量
~A
以下不正确的定义语句是（ ）。
double x[5]={1.0,2.0,3.0,4.0,5.0};
int y[5]={0,1,2,3,4,5};
char c1[]={'1','2','3','4','5'};
char c2[]={'a','b','c'};
~B
C语言中，凡未指定存储类别的局部变量的隐含存储类别是（ ）。
自动（auto）
静态（static）
外部（extern）
寄存器（register）
~A
如果要打开一个已经存在的非空文件“FILE”并进行修改，正确的语句是（ ）。
fp=fopen
("FILE","r");
fp=fopen("FILE","a+");
fp=fopen("FILE","w+");
fp=fopen("FILE","r+");
~D
下列程序的功能时：给r输入数据后计算半径为r的圆面积s。程序在编译时出错。
main()
{ int r; float s;
scanf("%d",&r);
s=pi*r*r;
printf("s=%f\n",s);
}
出错的原因是（）。
注释语句书写位置错误
存放圆半径的变量r不应该定义为整型
输出语句中格式描述符号非法
计算圆面积的赋值语句中使用了非法变量
~D
以下叙述错误的是（）。
在程序中凡是以“#”开始的语句行都是预处理命令行
预处理命令行的最后不能以分号表示结束
#define MAX是合法的宏定义命令行
C程序对预处理命令行的处理是在程序执行的过程中进行的
~C
下列叙述中正确的是（）。
预处理命令行必须位于源文件的开头
在源文件的一行上可以有多条预处理命令
宏名必须用大写字母表示
宏替换不占用程序的运行空间
~D
若程序中有宏定义行：#define N 100，则下列叙述中正确的是（）。
宏定义中定义了标识符N的值为整数100
在编译程序对C源程序进行预处理时用100替换标识符N
对C源程序进行编译时用100替换标识符N
在运行时用100替换标识符N
~B
程序
#include
#define M 5
#define N M+M
main()
{ int k;
k=N*N*5;
printf("%d\n",k);
}
的输出结果是（）。
100
50
55
45
~C
下列叙述中正确的是（）。
预处理命令行必须位于C源程序的起始位置
在C语言中，预处理命令行都以#开头
每个C程序必须在开头包含预处理命令行：#include
C语言的预处理不能实现宏定义和条件编译的功能
~B
C语言的编译系统对宏命令的处理是（）。
在系统对源程序进行编译前
和其他语句的编译同时进行
在程序连接时进行
在程序运行时进行
~A
以下叙述中不正确的是（）。
预处理命令行都必须以“#”号开始，结尾不加分号
在程序中凡是以“#”开始的语句行都是预处理命令行
C程序在执行过程中对预处理命令进行处理
预处理命令可以放在程序的任何位置
~C
下面叙述中正确的是（）。
C语言中预处理是指完成宏替换和文件包含指定的文件的调用
预处理命令只能位于C源程序文件的首部
预处理命令可以放在程序中的任何位置
预处理命令结尾需要加分号
~C
以下有关宏替换的叙述不正确的是（）。
使用宏定义可以嵌套
宏定义仅仅是符号替换
双引号中出现的宏名不替换
宏名必须用大写字母表示
~D
在“文件包含”预处理语句的使用形式中，当#include后面的文件名用尖括号（<>）括起时，寻找被包含文件的方式是（）。
仅仅搜索当前目录
仅仅搜索源程序所在目录
在标准目录下查找指定文件
先在源程序所在目录搜索，如没找到
，再按系统指定的标准目录查找
~C
下列对结构体类型变量td的定义中，错误的是（）。
typedef struct aa struct aa
{ int n; { int n;
float m; float m;
}AA; }td;
AA td;
struct struct
{int n; { int n;
float m; float m;
}aa; }td;
struct aa td;
~C
下列叙述错误的是（）。
可以通过typedef增加新的类型
可以用typedef将已存在的类型用一个新的名字来代表
用typedef定义新的类型名后，原有的类型名仍有效
用typedef可以为各种类型起别名，但不能为变量起别名
~A
设有以下语句：
typedef struct TT
{char c;int a[4];}CIN;
则下列叙述中正确的是（）。
可以用TT定义结构体变量
TT是 struct类型的变量
可以用CIN定义结构体变量
CIN是struct TT类型的变量
~C
下列关于typedef的叙述错误的是（）。
用typedef可以增加新的类型
typedef只是将已存在的类型用一个新的名字来代表
用typedef可以为各种类型说明一个新名，但不能用来为变量说明一个新名
用typedef为类型说明一个新名，通常可以增加程序的可读性
~A
有以下结构体类型说明和变量定义中正确的是（）。
typedef struct struct REC
{ int n;char c;}REC; { int n;char c;};
REC t1,t2; REC t1,t2;
typedef struct REC; struct
{ int n=0;char c='A';}t1,t2; { int n;char c;}REC;
REC t1,t2;
~A
定义以下结构体数组:
struct st
{ char name[15];
int age;
}a[10]={"ZHAO",14,"WANG",15,"LIU",16,"ZHANG",17};
执行语句printf("%d,%c"a[2].age,*(a[3].name+2)))的输出结果为（）。
15,A
16,H
16,A
17,H
~C
设fp为指向某二进制文件的指针，且已读到此文件末尾，则函数feof(fp)的返回值为（）。
EOF
非0值
0
NULL
~B
读取二进制文件的函数调用形式为：fread(buffer,size,count,fp);,其中buffer代表的是（）。
一个文件指针，指向待读取的文件
一个整型变量，代表待读取的数据的字节数
一个内存块的首地址，代表读入数据存放的地址
一个内存块的字节数
~C
如果需要打开一个已经存在的非空文件“FILE"并进行修改，正确的语句是（）。
fp=fopen("FILE","r");
fp=fopen("FILE","a+");
fp=fopen("FILE","w+");
fp=fopen("FILE","r+");
若以"a+"方式打开一个已存在的文件，则以下叙述正确的是（）。
文件打开时，原有文件内容不被删除，位置指针移到文件末尾，可作添加或读操作
文件打开时，原有文件内容不被删除，只能进行读操作
文件打开时，原有文件内容被删除，只能进行写操作
以上各种说法都不正确
~A
使用fgets(str,n,p)函数从文件中读入一
个字符串，以下叙述错误的是（）。
字符串读入后会自动加入'\0'
fp是指向该文件的文件型指针
fgets函数将从文件中最多读入n-1个字符
fgets函数将从文件中最多读入n个字符
~D
- C语言期末2 期末考试试题及参考答案
- C语言期末考试题库试题及答案
- 2019年C语言期末考试题与答案
- c语言期末测试题附答案)
- 单片机c语言期末考试题
- c语言期末考试试题及答案
- C语言期末考试试题及详细答案
- c语言期末考试试题
- 大一C语言期末考试题
- 大学C语言期末考试试题及答案
- c语言期末考试题库
- c语言期末考试试题及答案
- 华中科技大学C语言期末考试题库试题及答案汇总
- C语言期末考试题(含答案)
- C语言期末考试_试题及答案_最新201
- C语言期末考试题目
- 大学计算机C语言期末考试复习试题及答案 (32)
- C语言期末考试复习题及答案3
- C语言期末考试试题及答案
- 大学C语言期末考试习题集(带详解答案)