C语言选择题复习精选.

选择题复习
1．表达式“(a=4*5, b=a*2), b-a, a+=2”的值是（C）。

A．2 B．20 C．22 D．42
2．以下是一个自定义函数的头部，其中正确的是（C ）。

A．int fun(int a[ ], b) B．int fun(int a[ ], int a)
C．int fun(int*a, int b) D．int fun(char a[ ][ ], int b)
3．以下数组声明语句中正确的是（D ）。

A．int n, a[n]; B．int a[ ];
C．int a[2][3]={{l},{2},{3}}; D．int a[ ][3]={{l},{2},{3}};
4．已知在某C语言编译系统中表达式sizeof(int)的值是2，如果希望将常量-70 000正确地保存在一个变量a中，该变量声明语句应当是（B ）。

A．int a; B．long int a; C．unsigned int a; D．unsigned int a;
5．以下声明语句中，用于声明一个行指针变量的是（C ）。

A．int *p(int); B．int *p; C．int (*p)[3]; D．int (*p)(int);
6．在以下程序中，需要在fun函数中声明一个int型的变量，以下选项中（A ）不能用做该变量的名字。

#include <math.h>
int y;
main( )
{ int a=1;
fun(a);
}
int fun(int x)
{_______; ／*int型变量声明语句位置*／
… ／*若干执行语句*／
}
A．x B．y C．fabs D．fun
7．如有语句“int x,y=0,z,*p[3]; p[0]=&x; p[1]=&y; p[2]=&z;”，以下表达式中有语法错误的是（B ）。

A．y++ B．p++ C．*++p[0] D．(*p[0])++
8．设有声明语句“int a[3][3]={1,2,3,4,5,6,7,8,9};”，以下语句中除（D ）外均能输出a[1][2]的值。

A．printf("％d ",*(*(a+1)+2)) B．printf("%d ",*(＆a[2][0]-1));
C．printf("%d ",*(a[1]+2)); D．printf("%d ",*(a+1)[2]);
9．已知有声明语句int x=8，则下列表达式中，值为2的是（B ）。

A．x+=x-=x B．x% = x-2 C．x>8?x=0:x++ D．x／= x + x
10．以下关于函数的叙述中正确的是（D ）。

A．在函数体中可以直接引用另一个函数中声明为static类别的局部变量的值
B．在函数体中至少必须有一个return语句
C．在函数体中可以定义另一个函数
D．在函数体中可以调用函数自身
11．若有声明语句“int a[10], b[3][3];”，则以下对数组元素赋值的操作中，不会出现越界访问的是（D ）。

A．a[-1]=0 B．a[10]=0 C．b[3][0]=0 D．b[0][2]=0
12．若有声明语句“char ch=’a’, *pc=&ch;”，以下语句中有语法错误的是（C ）。

A．(*pc)++; B．ch+= -‘a’ + ‘A’;
C．toupper(ch)=ch; D．ch++;
13．已知有声明语句“int a[5]={1, 2, 3, 4, 5}, *p, i;”，以下语句中（C ）不能正确输出a数组全部元素的值。

A．for(p=a, i=0;i<5;i++)printf("%d",*(p+i));
B．for(p=a;p<a+5;p++)printf("%d", *p);
C．for(p=a, i=0;p<a+5;p++, i++)printf("%d", p[i]);
D．for(p=a;p<a+5;p++)printf("%d", p[0]);
14．已知某程序如下：
float p=1.5;
#define p 2.5
main( )
{printf("%f", p);}
则main函数中标识符p代表的操作数是（D ）。

A．float型变量B．double型变量
C．float型常量D．double型常量
15．已有声明“int S[2][3]”，以下选项中（A ）正确地引用了数组S中的基本元素。

A．S[1>2][!1] B．S[2][0] C．S[1] D．S
16．逻辑“异或”运算可描述为“a xor b”，其中a和b为参加运算的两个操作数，运算结果为当且仅当a、b两个操作数中只有一个为真时才为真，其他情况下均为假。

以下表达式中（D ）可以正确表示逻辑“异或”运算。

A．a || b B．a && b C．(a&&b)&&!(a || b) D．(a || b)&&!(a&&b) 17．若有声明“int a[5],*b=a,(*c)[3],*d[3];”，则在以下表达式中有语法错误的是（C ）。

A．a[0]=0 B．b[0]=0 C．c[0]=0 D．d[0]=0
18．若有声明：
int k, a, b;
unsigned long y=5;
double x=1.23;
则以下表达式中正确的是（D ）。

A．x%(-5) B．x=y[6] C．k=(a=1,b=2,&a + &b) D．a+=a- = (b=2) * (a = 3) 19．一个用C语言编写的源程序中，（A ）是必不可少的。

A．取名为main的函数定义B．#include<stdio.h>
C．变量声明D．注释
20．以下声明中正确的是（D ）。

A．int n=2, a[n]={10}; B．int n=10, *p[2]=&n;
C．int n=10, a[2]={n}; D．int a[2][2]={10}, (*p)[2]=a+1;
21、若有函数fun的定义为
void fun(…)
{static int a=1;
…
}
则下列叙述中不正确的是（B ）。

A．在每次调用fun函数时，变量a的值是上次调用结束时a的值
B．在fun函数之外，可以用变量名a直接引用a的值
C．在其他函数中，可以出现声明double a=2.5;
D．fun函数的形式参数不能取名为a
22．以下单目运算符均只需要一个操作数，其中要求操作数的类型只能是指针型的是（D ）。

A．& B．++ C．! D．*
23．已知有声明“int good=l; ”，若要使得表达式“p="good"+good”无语法错误(包括警告错误)，p应当声明为（B ）。

A．char p; B．char*p; C．int p; D．int *p;
24．以下全局变量声明中正确的是（D ）。

A．auto int i=1; B．float a=1, b=0.5, c=a+b;
C．char for=1; D．static char ch;
25．若已有声明“double a[2][3]={1, 2, 3, 4, 5, 6};”，则下列表达式中不能正确引用a[1][1]值的是（C ）。

A．*(a[0]+4)
B．*(a[1]+1)
C．*(*(a+3)+1)
D．*(*a+4)
26、已有声明“int a[5];”，以下表达式中不能正确取得a[1]指针的是（B ）。

A．&a[1]
B．++a
C．&a[0]+1
D．a+l
27．以下关于语句的说法中正确的是（A ）。

A．do-while语句的循环体至少会被执行1次
B．while语句的循环体至少会被执行1次
C．for语句的循环体至少会被执行1次
D．在C语言中只能用do、do-while或for语句实现循环结构
28．已知函数f的定义如下：
void f(void)
{printf("That’s great! ");}
则调用f函数的正确形式是（B ）。

A．f;
B．f();
C．f(void);
D．f(1);
29．以下程序在编译时在第三行报错“Redeclaration of ‘a’in function d”，如果决定修改该行声明中出现的局部变量a的名字，则下列选项中不能用来替换变量名a的是（A ）。

int b;
void d(int a)
{ int f; double a=1;
printf("%d",a);
}
main( )
{int e=1;d(e);}
A．f B．e C．d D．b
30、以下语句中不包含关键字的是（A ）。

A．x=sqrt(2);
B．while(x!=0)x--;
C．if(x<0)x=-x;
D．return x;
31．在main函数体内部和外部均允许出现的实体是（B ）。

A．预处理命令
B．语句
C．另一函数的定义
D．函数形式参数声明
32、已知有声明int x=2：，以下表达式中值不等于8的是（D ）。

A．x+=2,x*2
B．x+=x*=X
C．(x+7)/2*((x+1)%2+1)
D．x*7.2/x+1
33、执行以下程序时，
#include<stdio.h>
main()
{ int a; float b;
scanf("%3d%f",&a,&b);printf("%d\t%f",ab);
}
若要求变量a和b分别从键盘获得输入值45和678.0，则以下四种输入数据中( 代表“空格”键，<CR>代表“回车”键)，不能达到该要求的输入数据是（C ）。

A．45 678<CR>
B．45<CR>678<CR>
C．45,678<CR>
D．045678<CR>
34．下列程序段中，能将变量x、y中值较大的数保存到变量a、值较小的数保存到变量b 的程序段是（C ）。

A．if(x>y)a=x;b=y;else a=y;b=x;
B．if(x>y){a=x;b=y;}else a=y;b=x;
C．if(x>y){a=x;b=y;}else{a=y;b=x;}
D．if(x>y){a=x;b=y;}else(x<y){a=y;b=x;}
35．已知函数fun的定义如下：
void fun(int x[], int y)
{ int k;
for(k=0;k<y;k++)
x[k]+=y;
}
若main函数中有声明int a[10]={10}及调用fun函数的语句，则正确的fun函数调用形式是（C ）。

A．fun(a[ ],a[0]);
B．fun(a[0],a[0]);
C．fun(&a[0],a[0]);
D．fun(a[0],&a[0]);
36．设有下列程序段：
static char b=2;
void Y ( )
{ static float d=4;……}
int a=1;
void X ( )
{ int c=3;……}
关于程序段中各变量的属性，以下叙述中错误的是（D ）。

A．a是全局变量，函数X可以访问，函数Y不能访问
B．b是全局变量，函数X和函数Y都可以访问
C．c是动态变量，函数X可访问，函数Y不可访问
D．d是静态变量，函数X和函数Y都可以访问
37、若有如下声明和语句：
int t[3][3], *pt[3], k;
for(k=0; k<3;k++) pt[k]=&t[k][0];
则表达式*(*(pt+1)+2)所引用的是（C ）。

A．t[2][0] B．&t[2][0] C．t[1][2] D．&t[1][2]
38．设有声明float a=1.23456; int i;，欲将a中的数值保留小数点后两位，第三位进行四舍五入运算，能实现该功能的表达式是（A ）。

A．i=a*100+0.5, a=i/100．0 B．a=(a*100+0.5)/100.0
C．a=((int)a*100+0.5)/l00.0 D．a=(a/100+0.5)/100.0
39．若已有声明“int x=4, y=3;”，则表达式x < y ? x++: y++的值是（B ）。

A．2 B．3 C．4 D．5
40．设有变量声明“char c;”, 执行“for (; c=(getchar( ) !=’\n’) ; )printf("%c", c); ”时，从键盘上输入“ABCDEFG↙”之后，输出的结果是（C ）。

A．ABCDEFG B．AABBCCDDEEFFGG
C．非字母数字字符D．语句不能执行
41．以下表示数学式“a<b<c”的逻辑表达式中，错误的是（A ）。

A．a<b<c B．a<b&&b<c C．!(a>=b)&&!(b>=c) D．!(a>=b||b>=c) 42．下面关于循环语句for、while、do_while的叙述中，正确的是（D ）。

A．三种循环语句的循环体都必须放入一对花括号中
B．三种循环语句中都可以缺省循环终止条件表达式
C．三种循环语句的循环体都至少被无条件地执行一次
D．三种循环语句都可能出现无穷循环
43、若有声明“int a[]={l, 2, 3, 4}, *p, i;”，则以下程序段中不能输出13的是（B ）。

A．for(i=0;i<4;i+=2)printf("％d", a[i]);
B．for(p=0;p<4;p+=2)printf("％d", a[p]);
C．for(p=a;p<a+4;p+=2)printf("％d", *p);
D．for(p=a, i=0; i<4;i+=2)printf("％d", p[i]);
44、下列叙述中正确的是（C ）。

A．main函数必须出现在其他函数之前
B．main函数中至少必须有一条语句
C．C程序总是从main函数的第一条语句开始执行
D．C程序总是在执行完main函数的最后一条语句后结束
45．已知有结构定义和变量声明如下：
struct student
{ char name[20];
int score;
struct student *h;
}stu, *p; int *q;
以下选项中错误的是（C ）。

A．p=&stu; B．q=&stu.score; C．scanf("%s%d", &stu); D．stu.h=p;
46、设有声明“int p[10]={1, 2}, i=0;”，以下语句中与“p[i]=p[i+1], i++;”等价的是（D ）。

A．p[i]=p[i+1]; B．p[++i]=p[i]; C．p[++i]=p[i+1]; D．i++, p[i-1]=p[i]; 47．设有结构定义及变量声明如下：
struct product
{ char[5];
floadt price;
}y[4]={ "100", 100};
以下表达式中错误的是（D ）。

A．(*y).code[0]=’2’;B．y[0].code[0]=’2’C．y->price=10; D．(*y)->price=10; 48．若有声明“int a=3, b=4, c=5;”，则下列表达式中值为0的是（D ）。

A．a&&b=0 B．a<=b C．a||b&&c D．!(!c||1)
49．已知有声明“long x, y;”，且x中整数的十进制表示有n位数字（4<n<10），若要求去掉整数x十进制表示中的最高位，用剩下的数字组成一个新的整数并保存到y中，则以下表达式中能正确实现这一功能的是（C ）。

A．y=x/(10*(n-1))
B．y=x%(10*(n-1))
C．y=x%(long)pow(10, n-1)
D．y=x%(10^(n-1))
50．已知有声明“int x, y;”，若要求编写一段程序实现“当x大于等于0时y取值1，否则y 取值-1”，则以下程序段中错误的是（C ）。

A．if(x>=0)y=1; else y=-1;
B．y=x>=0?1:01;
C．switch()
{case x>=0:y=1; break;
default:y=-1;
}
D．switch(x-abs(x))
{ case 0:y=1; break;
default:y=-1;
}
51、已知有声明“int m[]={5,4,3,2,1},i=0;”，下列对m数组元素的引用中，错误的是（B ）。

A．m[++i]
B．m[5]
C．m[2*2]=0
D．m[m[4]]
52、若函数调用时的实参为变量，则以下关于函数形参和实参的叙述中正确的是（D ）。

A．实参和其对应的形参占用同一存储单元
B．形参不占用存储单元
C．同名的实参和形参占用同一存储单元
D．形参和实参占用不同的存储单元
53．C语言规定，在一个源程序中main函数的位置（D ）。

A．必须在最开始
B．必须在最后
C．必须在预处理命令的后面
D．可以在其他函数之前或之后
54、已知有声明“int a=3, b=4, c;”，则执行语句“c=1/2*(a+b);”后，c的值是（A ）。

A．0
B．3
C．3.5
D．4
55、已知字母A的ASCII码是65，字母a的ASCII码是97，变量c中存储了一个大写字母的编码。

若要求将c中大写字母编码转换成对应小写字母编码，则以下表达式中不能实现该功能的是（D ）。

A．c=tolower(c)
B．c=c+32
C．c=c-‘A’+’a’
D．c= (c +’A’)%26-‘a’
56．已知有定义和声明：
struct student
{ int no;
char name[20];
struct {int year, month, day;}birth;
}s;
若要求将日期“1989年11月12日”保存到变量s的birth成员中，则能实现这一功能的程序段是（D ）。

A．year=1989; month=11; day=12;
B．s.year=1989;s.month=11; s.day=12;
C．birth.year=1989; birth.month=11; birth.day=12;
D．s.birth.year=1989; s.birth.month=11; s.birth.day=12;
57、执行以下程序后的结果是（C ）。

#include <stdio.h>
void main()
{ int x=3;
Do
{
printf("%d\t", x=x-3);
}while(!x);
}
A．输出一个数：0
B．输出一个数：3
C．输出两个数：0和-3
D．无限循环，反复输出数
58．设有声明“int a=4, b=3, c=5;”，以下4个程序段中有3个程序段的执行效果是相同的，另一个执行效果不同的是（C ）。

A．if(a>b) c=a, a=b, b=c;
B．if(a>b) ｛c=a, a=b, b=c;｝
C．if(a>b) c=a; a=b; b=c;
D．if(a>b) ｛c=a; a=b; b=c;｝
59、以下关于if语句和switch语句的叙述中错误的是（D ）。

A．if语句和switch语句都可以实现算法的选择结构
B．if语句和switch语句都能实现多路（两路以上）选择
C．if语句可以嵌套使用
D．switch语句不能嵌套使用
60．若有声明语句“char s1[10]={0}，s2[10]= "books";”，则能将字符串"books"赋给数组s1保存的表达式是（D ）。

A．s1= "books"; B．strcpy(s2, s1);
C．s1=s2; D．strcat(sl, s2);
61．已知A盘根目录下的一个文本数据文件data.dat中存储了100个int型数据，若需要修改该文件中已经存在的若干个数据的值，只能调用一次fopen函数，已有声明语句“FILE *fp;”，则fopen函数的正确调用形式是（A ）。

A．fp=fopen("a:\\data.dat","r+");
B．fp=fopen("a:\\data.dat ","w+");
C．fp=fopen("a:\\data.dat","a+ ");
D．fp=fopen("a:\\data.dat","w ");
62．数组和链表都可以用于存储一组彼此有关联的数据，以下说法中不正确的是（B ）。

A．数组占用一块连续的存储区域，链表可能占用若干块不连续的存储区域
B．数组和链表所占用的存储区域均不能在程序运行期间动态地分配
C．数组中的数据可以随机存取或顺序存取，链表中的数据只能顺序存取
D．数组的长度是固定的，链表的长度是不固定的
63．设有定义和声明语句：
typedef struct dtype
{int a;
struct dtype *b;
}node;
static node x[3]={5, &x[1], 7, &x[2], 9, ’\0’}, *prt=&x[0];
下列选项中，表达式值不为5的是（A ）。

A．x[1].b->a-2
B．Ptr->b->a-2
C．(ptr+1)->a-2
D．ptr->a
64．在以下程序中，需要在main函数之后定义一个函数，以下选项中（D ）可以用做该函数的名字。

#define P 3.14
int y;
main( )
{ int a = 1;
函数名(a);
… ／*若干执行语句*／
}
int函数名(int x)
{return x*x;}
A．main B．y C．P D．print
65．已知有语句“FILE *fp;int x=123;fp =fopen("out.dat", "w");”，如果需要将变量x的值以文本形式保存到一个磁盘文件out.dat中，则以下函数调用形式中正确的是（B ）。

A．fprintf("%d", x); B．fprintf(fp, "%d", x);
C．fprinff("%d", x, fp); D．fprintf("out.dat", "%d", x);
66．已知有声明语句“char s1[10]= "12345", s2[10]= "abcde", s3[10];”，以下语句中能将s1中存储的字符串和s2中存储的字符串正确交换的是（D ）。

A．s3=s1,s1= s2, s2 = s3;
B．s3[0] = s1[0],s1[0] = s2[0],s2[0]=s3[0];
C．strcpy(s3[0],s1[0]),strcpy(s1[0],s2[0]),strcpy(s2[0],s3[0]);
D．strcpy(s3,s1), strcpy(sl, s2), strcpy(s2, s3);
67．在定义任何一个函数时，下列选项中（B ）是不可缺少的。

A．函数名之前的数据类型B．函数名之后的一对圆括号
C．形式参数声明D．函数体中的语句
68．已有数据类型定义和变量声明如下：
struct person
{int num;
char name[20], sex;
struct {int class; char prof[20];}in;
}a={20,"Li ning",’M’, {5,"computer"}}, *p= & a;
下列语句中正确的是（B ）。

A．printf("%s", a->nname); B．printf("%s", p->in．prof);
C．printf("%s", *); D．printf("%c", p->in->prof);
69．若有以下程序：
int x;
int f(int y)
{return标识符;}
# include <stdio.h>
int w;
main( )
{int z=2;f(z);…}
则在函数f中return语句后允许出现的标识符是（B ）。

A．x或w B．x或y C．z或w D．NULL
70．以下跳转语句中，只有（C ）可以选择不唯一的跳转目的地。

A．continue; B．break; C．goto标识符; D．return;
71．在缺省情况下，标准C的编译系统中预定义的标准输出流stdout直接连接的设备是（D ）。

A．软盘B．硬盘C．键盘D．显示器
72．已有枚举类型定义：“enum letter{A, B, C=7, D, E};”，以下表达式中除（D ）外，其他表达式的机内值均等于10。

A．’\xb’-1 B．B+E C．010+2 D．0xf-3
73．已知数据类型定义和变量声明如下：
struct sk
{int a; float b;}data[2], *p;
若有p=data，则以下对data[0]中成员a的引用中错误的是（A ）。

A．data[0]->a B．data->a C．p->a D．(*p).a
74．已知有声明“char c=’1’; int x=300; float t=35000; double d=3.1234567e10;”，则以下表达式求值时除（D ）外其结果都可能是不准确的。

A．x=t/c B．t=d/x C．t=d/1e5f D．t = x + c
75．已有预处理命令和声明如下：
#define N 10
int a=2, c=1;
double b=1.2;
下述程序段正确的是（C ）。

A．switch(a)
{ case c: a--;break;
case c+1: a++;break;
}
B．switch(a)
{ case N>0: a=1;break;
case 1: a=0;break;
}
C．switch(a)
{ case 2: b++;break;
case ‘0’: b=3;
}
D．switch(b)
{ case 1.0: b++;break;
case 1.2: b=1;break;
}
76．若有以下声明和定义：
void fun(int c){printf("%d", c);}
main( )
{void (*a) (int)=fun, *b(int), (*c) ( int );
／*调用fun函数语句位置*／
}
void *b(int c){ }
如果在main函数中需要调用fun函数，以下调用语句中错误的是（C ）。

A．fun(1); B．(*a)(1); C．b=fun; (*b)(1); D．c=a; (*c)(1);
77．以下叙述正确的是（A ）。

A．一个用C语言编写的程序在运行时总是从main函数开始逐条执行语句的
B．main函数是系统库函数
C．main函数中每行只能出现一条语句
D．main函数必须出现在所有其他函数之前
78．以下关于函数形式参数的声明中正确的是（A ）。

A．int a[ ]
B．int a [ ][ ]
C．int a[ ]={0}
D．int a[2][ ]
79．关于函数返回值，以下叙述中正确的是（B ）。

A．函数返回值的类型由函数体内return语句包含的表达式的类型决定
B．函数返回值的类型由函数头部定义的函数类型决定
C．若函数体中有多个return语句，则函数的返回值是排列在最后面的return语句中表达式的值
D．若函数体内没有return语句，则函数没有返回值
80．已知字符A的机内编码为65，则执行下列函数调用语句时，不能输出字符B的是
（B ）。

A．putchar(‘B’);
B．putchar("B");
C．putchar(66);
D．putchar(‘\x42’);
81．下列一维数组的声明中正确的是（C ）。

A．int a[ ];
B．int n=10, a[n];
C．int a[10+1]={0};
D．int a[3]={1, 2, 3, 4};
82．已知有结构类型定义：
typedef struct ex{long int num;
char sex;
struct ex*next;
}student;
下列叙述错误的是（B ）。

A．struct ex是结构类型
B．student是结构类型的变量名
C．ex可缺省
D．student不可缺省
83．下列程序段的输出结果是（C ）。

int i, x[3][3]={9, 8, 7, 6, 5, 4, 3, 2, 1}, *p=&x[1][1];
for(i=0;i<4;i+=2)printf("%d", *(p+i));
A．5 2
B．5 1
C．5 3
D．9 7
84．已知有声明”char a[6], *p=a;”，现需要在程序运行过程中将字符串"Hello"，保存到a数组中，则下列选项中能正确完成此操作的表达式是（D ）。

A．a[6]="Hello"
B．a="Hello"
C．p="Hello"
D．strcpy(a, "Hello")
85．若要使表达式“p++”无语法错误，则变量p不能声明为（D ）。

A．int p;
B．double p;
C．int *p;
D．struct{int x;}p;
86．以下函数定义中正确的是（C ）。

A．int fun(int a, b){ }
B．int fun(int a[][]){}
C．int fun(void){}
D．int fun(static int a, int b){}
87．已知有函数f的定义如下：
int f(int a, int b)
{ if(a<b)return(a, b);else return(b, a); }
在main函数中若调用函数f(2, 3)，得到的返回值是（B ）。

A．2
B．3
C．2和3
D．3和2
88．下列各选项都是在C语言程字段中增加的注释，其中注释方法错误的是（B ）。

A．void main(/*int argc, char, *argv[ ]*/)
{ }
B．void main( )
{pri/*remark*/ntf("name");}
C．void main( )
{ int x/*=10*/;
printf("%d", x);
}
D．void main( )
{ int x=10;
/*printf(" %d", x);*/
}
89．若有定义和声明typedef enum{green, red, yellow, blue, b1ack}color; color flower;，则下列语句中正确的是（B ）。

A．green=red;
B．flower=red;
C．color=red;
D．enum=red;
90．若已定义一个有返回值的函数，则以下关于调用该函数的叙述中错误的是（D ）。

A．函数调用可以作为独立的语句存在
B．函数调用可以出现在表达式中
C．函数调用可以作为一个函数实参
D．函数调用可以作为一个函数形参
91．对应main函数中的fun函数调用语句，以下给出的四个fun函数首部中，错误的是（D ）。

main( )
{ int a[50], n;
fun(n, &a[9]);
}
A．void fun(int m, int x[])
B．void fun(int s, int h[41])
C．void fun(int p, int *s)
D．void fun(int n, int a)
92．若有声明“int i; float x; char a [50]; ”，为使i得到值1，x得到值3.1416，a得到值yz，当执行语句“scanf("%3d%f%2s", &i, &x, a);”时，正确的输入形式是（C ）。

A．1, 3.1416, yz↙
B．13.1416yz↙
C．001 3.1416 yz↙
D．i=001, x=3.1416,a=yz↙
93．程序段“int x=3; do{printf("%d", x--); }while(!x);”的执行结果是（C ）。

A．3 2 1
B．2
C．3
D．死循环
94．假定已有声明“char a[30], *p=a;”，则下列语句中能将字符串“This is a C program．”正确地保存到数组a中的语句是（D ）。

A．a[30]= "This is a C program.";
B．a="This is a C program.";
C．p="This is a C program.";
D．strcpy(p, "This is a C program.");
95．若需要对一个数据文件abc．txt中的数据做加密处理并且限定只能做一次打开文件操作，则在“fp=fopen("abc.txt", 模式字符串);”中，模式字符串应当是（B ）。

A．"w+"
B．"r+"
C．"a+"
D．"r"
96．下列在C语言源程序的错误中，通常不能在编译时发现的是（C ）。

A．括号不匹配
B．非法标识符
C．数组元素下标值越界
D．程序结构不完整
97．若有程序段“char c=256; int a=c;”，则执行该程序段后a的值是（C ）。

A．256
B．65536
C．0
D．-1
98．若有枚举类型定义“enum list1{x1, x2, x3, x4=6, x5, x6};”，则枚举常量x2和x6代表的值分别是（B ）。

A．1，6
B．1，8
C．2，6
D．2，8
99．若程序中已有相应的声明，下列语句中错误的是（D ）。

A．printf(i==4? "％6d＼n":"％6d", i);
B．i==4 ? printf("％6d＼n", i):printf("％6d", i);
C．for(i=10; ; i--)if(i==1)break;
D．for(i=10; ;)if(i--);break;
100．已知有声明“char a[ ]= "It is mine", *p="It is mine";”，下列叙述中错误的是（B ）。

A．strcpy(a, "yes")和strcpy(p, "yes")都是正确的
B．a="yes"和p="yes"都是正确的
C．*a等于*p
D．sizeof(a)不等于sizeof(p)。