一、判断题：T为正确F为错误
- C程序的基本组成单位是函数T
- C程序可以由一个或多个函数组成T
- C语言可以不用编译就能被计算机识别执行F
- main()函数必须放在其它函数之前F
- 每个C程序中都必须要有一个main()函数T
- 在C程序中main()函数的位置是固定的F
- C程序中的main()函数必须放在程序的开始位置F
- C语言编译时不检查语法F
- C程序中注释部分可以出现在程序中任意合适的地方T
- C程序中一行可以写多条语句T
- 分号是C语句之间的分隔符，不是语句的一部分F
12.花括号“{”和“}”只能作为函数体的定界符F - C程序中的每行只能写一条语句F
- C程序的执行总是从main函数开始，在main函数结束F
- C程序的执行总是从main函数开始，在程序的最后一个函数中结束F
- ++(i+1);是非法的赋值语句T
- 用户标识符中不可以出现中划线，但可以出现下划线T
- 用户标识符中可以出现下划线，但不可以放在用户标识符的开头F
- C语言中，Area与area是不同的标识符T
- C语言中有逻辑类型F C语言有整型、实型、字符型
- int a=b=0;是正确的定义语句F
- 1.2E0.5是符合C语言语法的实型常量F
- 假定x和y为double型，则表达式x=2,y=x+3/2的值是3.500000F
- 可以用关系运算符对字符串的大小进行比较F
- 两个字符串中的字符个数相同时才能进行字符串大小的比较 F 只要都是以\0结尾都可以比较大小
- 设有定义语句：char b= ‘\123’;则变量b包括4个字符F
- 若有定义语句：char s[10]=“1234567\0\0”;，则strlen(s)的值是9F
- a=b+c=1 是正确的赋值表达式F
- 若变量a、i已正确定义，且i已正确赋值，则 a=a++=5; 是正确的赋值语句F
- 除逗号运算符外，赋值运算符的优先级最低T
- C语言中，运算对象必须是整型数据的运算符是 %T
- 对于单目运算符++、–，它们的运算对象可以是任何变量和常量F
- 表达式：10！=9的值是 true F
- 表达式1||2||3||4的值是1 T
- 若变量c为char类型，则表达式(c>= ‘a’)&&(c<= ‘z’) 能正确判断出c为小写字母T
- 若变量c为char类型，则表达式 ‘a’<=c<= ‘z’ 能正确判断出c为小写字母F
- sizeof(float)的值是4 T
- sizeof(double)是一种函数调用 F
- if(x<y) {x++;y++;} 是正确的if语句 T
- if(x>y); 是正确的if语句 T
- 用do-while语句构成的循环,在while后的表达式为零时结束循环 T
- do-while语句构成的循环只能用break语句退出 F
- 对for(表达式1； ； 表达式3)可理解为 for(表达式1；0；表达式3) F
- break语句只能用于switch语句体中F
- continue语句的作用是：使程序的执行流程跳出包含它的所有循环F
- 在循环体内使用break语句和continue语句的作用相同F
- 当程序执行中，数组元素的下标超出所定义的下标范围时，系统将给出“下标越界”的出错信息 F
- 假定int类型变量占用两个字节，其有定义：int x[10]={0,2,4};，则数组x在内存中所占字节数是6 F
- 若有定义：int a[2][3];对a数组元素正确引用的是a[2][3]F
- 若有说明int s[3][4]={0};则只有元素s[0][0] 可得到初值0F。
- 不能在赋值语句中通过赋值运算符"="对字符型数组进行整体赋值T
- 字符型数组中可以存放字符串T
- 可以对整型数组进行整体输入、输出T
- 函数中的形式参数是局部变量F
- 在不同的函数中可以使用相同名字的变量T
- 在一个函数内定义的变量只在本函数范围内有效T
- 函数的定义和函数的调用均可以嵌套 F 定义不能嵌套，函数的调用可以嵌套
- 函数的定义可以嵌套，但函数的调用不可以嵌套F
- 函数的形参和实参分别占用不同的存储单元T
- C语言中，每个函数都可以被其它函数调用(包括main函数)F
- C语言中，在一个函数内部可以定义另一个函数F
- 实参和与其对应的形参共同占用一个存储单元F
- 只有当实参和与其对应的形参同名时才共占用存储单元F
- 若有以下函数调用语句： fun(a+b,(x,y),fun(n+k,d,(a,B)));在此函数调用语句中实参的个数是6 F
- 用户定义的函数中可以没有return语句T
- 用户定义的函数中可以有多个return语句，以便可以调用一次返回多个函数值F
- 当调用函数时，实参是一个数组名，则向函数传送的是数组的首地址 T
- 若用数组名作为实参，则传递给形参的是数组中全部元素的值 F
- C语言中形参的默认存储类别是自动(auto) T
- C语言中，宏替换没有数据类型限制 T
- C语言中，宏名必须用大写字母表示F
- C程序对预处理命令行的处理是在程序执行的过程中进行的 F
- 两个字符串中的字符个数相同时才能进行字符串大小的比较 F 只要两个字符串都以’\0’结尾就可以比较
- 当调用函数时，实参是一个数组名，则向函数传送的是数组的首地址 T
- break语句只能用于switch语句体中 F
- C程序中的main()函数必须放在程序的开始位置 F
- if(x>y); 是正确的if语句 F 无分号
- ++(i+1);是非法的赋值语句 T
- 若有以下函数调用语句： fun(a+b,(x,y),fun(n+k,d,(a,B)));在此函数调用语句中实参的个数是6 F
- 函数的形参和实参分别占用不同的存储单元T
- 在不同的函数中可以使用相同名字的变量T
- 表达式：10！=9的值是 true F
- C语言中，宏替换没有数据类型限制T
- C程序中注释部分可以出现在程序中任意合适的地方T
- 设有定义语句：char b= ‘\123’;则变量b包括4个字符 F \123为转义字符，是一个字符常量，斜线后面的是八进制数，可以由0开头，最多由3个八进制数组成。它只代表一个字符，此八进制数就是这个字符的代码。语句charb=’\123’是给字符变量赋初值，初值为一个字符。所以，选项D符合题意。
- 用do-while语句构成的循环,在while后的表达式为零时结束循环T
- if(x<y) {x++;y++;} 是正确的if语句T
- continue语句的作用是：使程序的执行流程跳出包含它的所有循环F
- 1.2E0.5是符合C语言语法的实型常量F
- 若有定义语句：char s[10]=“1234567\0\0”;，则strlen(s)的值是9F
- 若变量c为char类型，则表达式 ‘a’<=c<= ‘z’ 能正确判断出c为小写字母F
- 可以用关系运算符对字符串的大小进行比较F
- 每个C程序中都必须要有一个main()函数T
- 函数的定义和函数的调用均可以嵌套F
- sizeof(float)的值是4T
- C语言中有逻辑类型F
- 字符型数组中可以存放字符串T
- 分号是C语句之间的分隔符，不是语句的一部分F
- C程序可以由一个或多个函数组成T
- 若有说明int s[3][4]={0};则只有元素s[0][0] 可得到初值0F
- 用户定义的函数中可以有多个return语句，以便可以调用一次返回多个函数值F
- C语言中，每个函数都可以被其它函数调用(包括main函数)F
二、单选题
1.以下说法中正确的是( C )
A) C语言程序总是从第一个的函数开始执行
B) 在C语言程序中,要调用的函数必须在main()函数中定义
C) C语言程序总是从main()函数开始执行
D) C语言程序中的main()函数必须放在程序的开始部分
- 下选项中不是Ｃ语句的是( C )。
A) {int i; i++; printf(“%d\n”,i);}
B) ;
C) a=5,c=10 赋值表达式，不是赋值语句
D) { ; } - 以下选项中不能作为C语言合法常量的是
( A )
A) ‘cd’
B) 0.1e+6
C) “\a”
D) ‘\011’ - 若x,a,b和c均是int型变量，则执行表达式x=(a=1,b=2)后x的结果为( B )。
A) 1
B) 2 逗号表达式的值就是最后一个表达式的值
C) 3
D) 不确定 - 以下能正确定义整型变量a,b和c并为其赋初值1的语句是( D )。
A) int a=b=c=1;
B) int a,b,c=1;
C) a=b=c=1;
D) int a=1,b=1,c=1; - 字符串"\t\065\xff\n"中的字符数(不算’\0’)为( D )
A) 5 \t简单转义字符\065,八进制转义字符\xff十六进制,\n简单字符
B) 14
C) 8
D) 4 - 对两个静态函数A和B进行如下初始化：
char A[]=“ABCDEF”;
char B[]={‘A’,‘B’,‘C’,‘D’,‘E’,‘F’};
则下列叙述正确的是( D )。
A) A和B完全相同
B) A和B只是长度相等
C) A和B不相同，A是指针数组
D) A数组长度比B数组长 数组a中最后一个元素是字符串结束标识’\0’，所以a数组长度为7，而b数组长度为6 - 若有以下定义：
char a;int b;
float c;double d;
则表达式a*b+d-c值的类型为( D )
A) float
B) int
C) char
D) double - 在C语言中，运算对象必须是整型数的运算符是( A )
A) %
B) /
C) %和
D) ** - 有以下程序
main()
{ int x, y, z;
x=y=1;
z=x++,y++,++y;
printf("%d,%d,%d\n",x,y,z);
}
程序运行后的输出结果是
( C )
A) 2,3,3
B) 2,3,2
C) 2,3,1
D) 2,2,1 - 以下选项中，当x为大于1的奇数时，值为0的表达式是( D )
A) x%21 值为1
B) x/2 值为1
C) x%2!=0 值为1
D) x%20 - 以下程序的输出结果是( C )。
main()
{
int x=10,y=3;
printf("%d\n",y=x/y); \运算取整数
}
A) 0
B) 1
C) 3
D) 不确定的值 - 若a为int类型，且其值为3，则执行完表达式a+=a-=a*a后，a的值是( C )
A) -3
B) 9
C) -12
D) 6 - 有以下程序
main()
{
char a=‘a’,b;
printf("%c,",++a);
printf("%c\n",b=a++);
}
程序运行后的输出结果是
( A )
A) b,b
B) b,c
C) a,b
D) a,c - 设a、b、c、d、m、n均为int型变量，且a=5、b=6、c=7、d=8、m=2、n=2，则逻辑表达式(m=a>b)&&(n=c>d)运算后，n的值为( C )
A) 0 左边表达式为假则不执行右边
B) 1
C) 2
D) 3 - 设x、y、t均为int型变量，则执行语句：x=y=3;t=++x||++y;后，y的值为( C )
A) 不定值 左边表达式为真则不执行右边表达式
B) 4
C) 3
D) 1 - 有以下程序段
int k=0;
while(k=1)k++;
while循环执行的次数是( A ) k=1为赋值语句，非0则为真，死循环
A) 无限次
B) 有语法错，不能执行
C) 一次也不执行
D) 执行1次 - 能正确表示逻辑关系“a>=10或a<=0”的C语言表达式是( D )
A) a>=10 or a=10
B) a>=0|a<=10
C) a>=10&&a<=0
D) a>=10||a<=0 - 表示关系x≤y≤z的c语言表达式为( A )
A) (x<=y)&&(y<=z)
B) (x<=y)AND(y<=z)
C) (x<=y<=z)
D) (x<=y)&(y<=z) - 设有：int a=1, b=2, c=3, d=4, m=3, n=3; 执行 (m=a>b)||(n=c>d)后n的值为( A )。
A) 0 关系运算优先于赋值运算
B) 1
C) 2
D) 3 - 以下关于逻辑运算符两侧运算对象的叙述中正确的是
( D )
A) 只能是整数0或1
B) 只能是整数0或非0整数
C) 可以是结构体类型的数据
D) 可以是任意合法的表达式 - 若x和y都是int型变量，x=100，y=200，且有下面的程序片段：
printf("%d",(x,y));
上面程序片段的输出结果是( A )
A) 200
B) 100
C) 100 200
D) 输出格式符不够，输出不确定的值 - 在函数调用过程中，如果函数funA调用了函数funB，函数funB又调用了函数funA，则( B )
A) 称为函数的直接递归调用
B) 称为函数的间接递归调用
C) 称为函数的循环调用
D) C语言中不允许这样的递归调用 - 以下程序的输出结果是( D )
main()
{ int k=17；
printf("%d，%o，%x \n"，k，k，k)；
}
A) 17，021，0x11
B) 17，17，17
C) 17，0x11，021
D) 17，21，11 - x、y、z被定义为int型变量，若从键盘给x、y、z输入数据，正确的输入语句是( B )
A) INPUT x、y、z;
B) scanf("%d%d%d",&x,&y,&z);
C) scanf("%d%d%d",x,y,z);
D) read("%d%d%d",&x,&y;&z); - 有以下程序
main()
{
int i;
for(i=0;i<3;i++)
switch(i)
{
case 0: prinft("%d",i);
case 2: prinft("%d",i);
default: prinft("%d",i);
}
}
程序运行后的输出结果是( C )
A) 022111
B) 021021
C) 000122
D) 012 - C语言中用于结构化程序设计的三种基本结构是( A )
A) 顺序结构、选择结构、循环结构
B) if、switch、break
C) for、while、do-while
D) if、for、continue - 在嵌套使用if语句时，C语言规定else总是
( C )
A) 和之前与其具有相同缩进位置的if配对
B) 和之前与其最近的if配对
C) 和之前与其最近的且不带else的if配对
D) 和之前的第一个if配对 - 设有以下程序片段:
switch(X)
{
case ‘A’: printf(“A”);
case ‘B’: printf(“B”);
default: printf(“error”);
}
假设X=‘A’,程序输出结果是( D )
A) A
B) B
C) error
D) ABerror - 读程序：
main()
{ int num=0;
while (num<=2)
{ num++; printf("%d ",num);}
}
上面程序的输出结果是( C )
A) 1
B) 2 2
C) 1 2 3
D) 1 2 3 4 - 以下程序段的执行结果是( A )。
int x=5;
do{printf("%2d\n",x–);}
while(!x);
A) 5
B) 无任何输出
C) 4
D) 陷入死循环 - 设变量已正确定义，则以下能正确计算f=n!的程序段是
( D )
A) f=0;
for(i=1;i<=n;i++) f*=i;
B) f=1;
for(i=1;i<n;i++) f*=i;
C) f=1;
for(i=n;i>1;i++) f*=i;
D) f=1;
for(i=n;i>=2;i–) f*=i; - 以下程序的输出结果是( D )。
main()
{
int a, b;
for(a=1,b=1;a<=100;a++)
{
if(b>=10) break;
if(b%3==1)
{
b+=3;
continue;
}
}
printf("%d\n",a);
}
A) 101
B) 6
C) 5
D) 4 - 下列合法的数组定义是( D )。
A) int a[]=“string”; 整型数组不能定义字符串
B) int a[5]={0,1,2,3,4,5}; 下标越界
C) char a=“string”; 没有[]
D) char a[]={0,1,2,3,4,5}; - 以下定义语句中，错误的是( D )
A) int a[]={1,2};
B) char *a[3];
C) char s[10]=“test”;
D) int n=5,a[n]; 数组名不能为变量 - 以下正确的数组定义语句是( D )。
A) int y[1][4]={1,2,3,4,5};
B) float x[3][]={{1},{2},{3}};
C) long s[2][3]={{1},{1,2},{1,2,3}};
D) int m[1][4]={4}; - 以下程序的输出结果是( C )。
main()
{
int i,a[10];
for(i=9;i>=0;i–)
a[i]=10-i;
printf("%d%d%d",a[2],a[5],a[8]);
}
A) 258
B) 741
C) 852
D) 369 - 若有定义语句：int a[3][6]; ，按在内存中的存放顺序，a数组的第10个元素是( B )
A) a[0][4]
B) a[1][3]
C) a[0][3]
D) a[1][4] - 以下数组定义中不正确的是( D )
A) int a[2][3];
B) int b[][3]={0,1,2,3};
C) int c[100][100]={0};
D) int d[3][]={{1,2},{1,2,3},{1,2,3,4}}; - 以下程序的输出结果是( A )。
main()
{
int a[4][4]={{1,3,5},{2,4,6},{3,5,7}};
printf("%d%d%d%d\n",a[0][3],a[1][2],a[2][1],a[3][0]);
}
A) 0650
B) 1470
C) 5430
D) 输出值不定 - 以下程序的输出结果是
( B )
main()
{ char cf[3][5]={“AAAA”,“BBB”,“CC”};
printf(""%s"\n",cf[1]);;
}
A) “AAAA”
B) “BBB”
C) “BBBCC”
D) “CC”
；维字符数组可以看成由若干个一维字符数组组成，每行是一个一维字符数组。本题首先定义了一个数组ch[3][5]并给它们按行赋初值，即相当于给ch[0]赋值“AAAA”，给 ch[1]赋值“BBB”，给ch[2]赋值“BBB”，最后输出转义字符“’’”、ch[1]和转义字符“\”，因此输出为“BBB”． - 设有数组定义: char array [ ]=“China”; 则数组 array所占的空间为( C )
A) 4个字节
B) 5个字节
C) 6个字节
D) 7个字节 - 以下选项中，不能正确赋值的是( A )。
A) char s1[10];s1=“Ctest”;
B) char s2[]={‘C’,‘t’,‘e’,‘s’,‘t’};
C) char s3[20]=“Ctest”;
D) char *s4=“Ctest\n”; - 给出以下定义：
char x[]=“abcdfeg”;
char y[]={‘a’,‘b’,‘c’,‘d’,‘e’,‘f’,‘g’};
则正确的叙述为( C )。
A) 数组x和数组y等价
B) 数组x和数组y长度相同
C) 数组x的长度大于数组y的长度
D) 数组x的长度小于数组y的长度 - 若要求从键盘读入含有空格字符的字符串，应使用函数
( B )
A) getc()
B) gets()
C) getchar()
D) scanf() - 有语句：
char str1[10],str2[10]={“books”};
则能将字符串books赋给数组str1的正确语句是( B )。
A) str1={“Books”};
B) strcpy(str1,str2);
C) str1=str2;
D) strcpy(str2,str1); - 以下语句的输出结果是( A )
printf("%d\n",strlen("\tc\065\xff\n"));
A) 5 \t,c,\o65,\xff,\n 五个
B) 14
C) 8
D) 输出项不合法，无正常输出 - 若有语句int *point, a=4; 和point=&a; 下面均代表地址的一组选项是( D )。
A) a, point, *&a
B) &*a, &a, *point
C) *&point, *point, &a
D) &a, &*point, point - 设已有定义：float x;，则以下对指针变量p进行定义且赋初值的语句中正确的是( D )
A) float *p = 1024;
B) int *p = (float)x;
C) float p = &x;
D) float *p = &x; - 设有语句：int a=1,b=2,*p1=&a,*p2=&b; 以下可使指针p1指向变量b的赋值语句是( C )。
A) p1=*p2
B) *p1=p2
C) p1=p2
D) *p1=*p2 - 有以下程序
main()
{
int a[]={1,2,3,4,5,6,7,8,9,0},*p;
for(p=a;p<a+10;p++)
printf("%d,",*p);
}
程序运行后的输出结果是( A )
A) 1,2,3,4,5,6,7,8,9,0,
B) 2,3,4,5,6,7,8,9,10,1,
C) 0,1,2,3,4,5,6,7,8,9,
D) 1,1,1,1,1,1,1,1,1,1, - 若已定义char s[10]; 则在下面表达式中不能表示s[1]的地址的是( B )。
A) s+1
B) s++ =s[0]
C) &s[0]+1
D) &s[1] - 在以下选项中，操作不合法的一组是( B )。
A) int x[6], *p; p=&x[0];
B) int x[6], *p; *p=x;
C) int x[6], *p; p=x;
D) int x[6],p; p=x[0];
对于A和C都可使p指向数组x的首地址。D是把数组元素x[0]赋给p - 以下叙述中正确的是( B )`
A) 全局变量的作用域一定比局部变量的作用域范围大
B) 静态(static)类别变量的生存期贯穿于整个程序的运行期间
C) 函数的形参都属于全局变量
D) 未在定义语句中赋初值的auto变量和static变量的初值都是随机值 - 有以下程序
main()
{ char s[]=“159”,*p;
p=s;
printf("%c",*p++);
pritnf("%c",*p++);
}
程序运行后的输出结果是
( A )
A) 15
B) 16
C) 12
D) 59 - 以下语句或语句组中，能正确进行字符串赋值的是( D )
A) char *sp; *sp=“right!”;
B) char s[10]; s=“right!”;
C) char s[10]; *s=“right!”;
D) char *sp=“right!”; - 下面程序段的运行结果是( A )。
char *p= “abcdefgh”;
p+=2;
printf("%d\n", strlen(strcpy(p, “ABCD”)));
A) 6
B) 12
C) 4
D) 7 - 下面程序段的运行结果是( B )。
char str[ ]= “ABC”, *p=str;
printf("%d\n", *(p+3));
A) 67
B) 0
C) 字符’C’的地址
D) 字符’C’ - 以下程序运行后，输出结果是( C )
main()
{ char *s=“abcde”;
s+=2;
printf("%d\n"，s);}
A) cde
B) 字符c的ASCII码值
C) 字符c的地址
D) 出错 - 有以下程序：
main()
{ char *p[10]={“abc”,“aabdfg”,“dcdbe”,“abbd”,“cd”};
printf("%d\n", strlen(p[4]));
}
执行后输出结果是( A )
A) 2
B) 3
C) 4
D) 5 - 若有语句：char line[5]；，以下叙述中正确的是( A )
A) 定义line是一个数组，每个数组元素是一个基类型为char的指针变量
B) 定义line是一个指针变量，该变量可以指向一个长度为5的字符型数组
C) 定义line是一个指针数组，语句中的号称为间址运算符
D) 定义line是一个指向字符型函数的指针 - 设有如下定义: char *aa[2]={“abcd”,“ABCD”}；则以下说法中正确的是( D )。
A) aa数组成元素的值分别是"abcd"和ABCD"
B) aa是指针变量,它指向含有两个数组元素的字符型一维数组
C) aa数组的两个元素分别存放的是含有4个字符的一维字符数组的首地址
D) aa数组的两个元素中各自存放了字符串"abcd"和"ABCD"的首地址 - 以下函数调用语句中含有( B )个实参。
fun((exp1,exp2),(exp3,exp4,exp5));
A) 1
B) 2
C) 4
D) 5 - 以下所列的各函数首部中，正确的是( C )
A) void play(var a :integer,var b:integer)
B) void play(int a,b)
C) void play(int a,int b)
D) Sub play(a as integer,b as integer) - C语言中，函数值类型的定义可以缺省，此时函数值的隐含类型是( B )
A) void
B) int
C) float
D) double - 下面的函数调用语句中func函数的实参个数是( A )
func(f2(v1, v2), (v3, v4, v5), (v6, max(v7, v8)));
A) 3
B) 4
C) 5
D) 8 - 有以下程序
fun(int x, int y)
{ static int m=0, i=2;
i+=m+1; m=i+x+y; return m;
}
main()
{ int j=1, m=1, k;
k=fun(j,m); printf("%d,",k);
k=fun(j,m); printf("%d\n",k);
}
执行后的输出结果是
( B )
A) 5, 5
B) 5, 11
C) 11, 11
D) 11, 5 - 以下函数值的类型是
( A )
fun ( float x )
{ float y;
y= 3*x-4;
return y;
}
A) int
B) 不确定
C) void
D) float - 以下程序的输出结果是( C )
fun(int x, int y, int z)
{ z=xx+yy; }
main()
{ int a=31;
fun(5,2,a);
printf("%d",a);
}
A) 0
B) 2
C) 31
D) 无定值 - 有以下程序
void f(int x,int y)
{ int t;
if(x<y){ t=x; x=y; y=t; }
}
main()
{ int a=4,b=3,c=5;
f(a,b); f(a,c); f(b,c);
printf("%d,%d,%d\n",a,b,c);
}
执行后输出的结果是( D )
A) 3,4,5
B) 5,3,4
C) 5,4,3
D) 4,3,5 - 在调用函数时，如果实参是简单变量，它与对应形参之间的数据传递方式是( B )
A) 地址传递
B) 单向值传递
C) 由实参传给形参，再由形参传回实参
D) 传递方式由用户指定 - 有以下程序
void f(int b[])
{ int i;
for (i=2; i<6; i++)
b[i] *= 2;
}
main()
{ int a[10]={1,2,3,4,5,6,7,8,9,10}, i;
f(a);
for (i=0; i<10; i++)
printf("%d,", a[i]);
}
程序运行后的输出结果是( B )
A) 1,2,3,4,5,6,7,8,9,10,
B) 1,2,6,8,10,12,7,8,9,10,
C) 1,2,3,4,10,12,14,16,9,10,
D) 1,2,6,8,10,12,14,16,9,10, - 在C语言中，函数返回值的类型最终取决于( A )
A) 函数定义时在函数首部所说明的函数类型
B) return语句中表达式值的类型
C) 调用函数时主调函数所传递的实参类型
D) 函数定义时形参的类型 - 调用一个函数，此函数中没有return语句，下列说法正确的是：该函数( A )。
A) 没有返回值
B) 返回若干个系统默认值
C) 能返回一个用户所希望的函数值
D) 返回一个不确定的值 - 若有以下调用语句,则不正确的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) - 有以下程序
void swap(char *x, char *y)
{ char t;
t=*x; *x=*y; *y=t;
}
main()
{ char *s1=“abc”, *s2=“123”;
swap(s1,s2); printf("%s,%s\n",s1,s2);
}
程序执行后的输出结果是( C )
A) 123,abc
B) abc,123
C) 1bc,a23
D) 321,cba - 以下程序的输出结果( B )
#include<stdio.h>
sub(int x,int y,int * z)
{
*z=y-x;
}
main()
{
int a, b, c;
sub(10,5,&a);
sub(7,a,&b);
sub(a,b,&c);
printf("%d,%d,%d\n", a,b,c);
}
A) 5,2,3
B) -5,-12,-7
C) -5,-12,-17
D) 5,-2,-7 - 已定义以下函数
int fun( int *p)
{ return *p; }
fun函数返回值是( C )
A) 不确定的值
B) 一个整数
C) 形参p中存放的值
D) 形参p的地址值 - 已定义以下函数：
fun (char* p2, char* p1)
{ while ((*p2=*p1) != ‘\0’) {pl++;p2++;} }
函数的功能是( A )
A) 将p1所指字符串复制到p2所指内存空间
B) 将pl所指字符串的地址赋给指针p2
C) 对pl和p2两个指针所指字符串进行比较
D) 检查p1和p2两个指针所指字符串中是否有’\0’ - 有以下程序
#include <stdio.h>
int fun(int a, int b)
{ if (b==0) return a;
else return (fun(–a, --b));
}
main()
{ printf("%d\n", fun(4, 2)); }
程序的运行结果是( B )
A) 1
B) 2
C) 3
D) 4 - 以下程序的输出结果是( B )
int a,b;
void fun()
{ a=100; b=200; }
main()
{ int a=5, b=7;
fun();
printf("%d%d \n", a,b);
}
A) 100200
B) 57
C) 200100
D) 75 - 以下程序的输出结果是( D )
int f()
{ static int i=0;
int s=1;
s+=i; i++;
return s;
}
main()
{ int i,a=0;
for(i=0;i<5;i++) a+=f();
printf("%d\n",a);
}
A) 20
B) 24
C) 25
D) 15 - 下面程序的输出是( C )
fun3(int x)
{ static int a=3;
a+=x;
return(a);}
main()
{ int k=2, m=1, n;
n=fun3(k);
n=fun3(m);
printf("%d\n",n);}
A) 3
B) 4
C) 6
D) 9 - 若有定义：int a=8，b=5，c；，执行语句c=a/b+0.4;后，c的值为( B )
A) 1.4
B) 1
C) 2
D) 2.00000 - 以下合法的C语言赋值语句是( D )。
A) a=b=58
B) k=int(a+b);
C) a=58,b=59
D) --i; - 数字字符’0’的ASCII值为48，若有以下程序
main()
{
char a=‘1’,b=‘2’;
printf("%c,",b++);
printf("%d\n",b-a);
}
程序运行后的输出结果是( C )
A) 3,2
B) 50,2
C) 2,2
D) 2,50 - 有以下程序段
int a, b, c;
a=10; b=50; c=a;
if (a>b) a=b, b=c; c=a;
printf(“a=%d b=%d c=%d\n”, a, b, c);
程序的输出结果是( A )
A) a=10 b=50 c=10
B) a=10 b=50 c=30
C) a=10 b=30 c=10
D) a=50 b=30 c=50 - 下面程序段的运行结果是( C )
char a[ ]= “language”, *p;
p=a;
while (*p !=‘u’) { printf("%c",*p-32); p++; }
A) LANGUAGE
B) language
C) LANG
D) langUAGE - 设有定义：int a; float b; 执行 scanf("%2d%f",&a,&b);语句时，若从键盘输入876 543.0<回车>，a和b的值分别是
( A )
A) 876和543.000000
B) 87和6.000000
C) 87和543.000000
D) 76和543.000000 - 设变量定义91为int A=5,B=6,表达式(++A==B–)?++A:–B的值是( C )。
A) 5
B) 6
C) 7
D) 8 - 若有以下说明:
int a[12]={1,2,3,4,5,6,7,8,9,10,11,12};
char c=‘a’,d,g;
则数值为4的表达式是( D )
A) a[g-c]
B) a[4]
C) a[‘d’-‘c’]
D) a[‘d’-c] - 有以下程序
＃include “stdio.h”
int abc(int u,int v);
main ()
{
int a=24,b=16,c;
c=abc(a,b);
printf("%d\n",c);
}
int abc(int u,int v)
{ int w;
while(v)
{ w=u%v; u=v; v=w }
return u;
}
输出结果是( C )
A) 6
B) 7
C) 8
D) 9 - 有以下程序
main()
{ char a,b,c,d;
scanf("%c,%c,%d,%d",&a,&b,&c,&d);
printf("%c,%c,%c,%c\n",a,b,c,d);
}
若运行时从键盘上输入：6,5,65,66<回车> ,则输出结果是( A )(注：字符’A’的ASCII码为65)
A) 6,5,A,B
B) 6,5,65,66
C) 6,5,6,5
D) 6,5,6,6 - 下列程序的输出结果是( D )
main()
{ char *p1,*p2,str[50]=“xyz”;
p1=“abcd”;
p2=“ABCD”;
strcpy(str+2,strcat(p1+2,p2+1));
printf("%s",str); }
A) xyabcAB
B) abcABz
C) ABabcz
D) xycdBCD - 有以下程序
include <stdio.h>
main()
{ int a[]={1,2,3,4,5,6,7,8,9,10,11,12,},*p=a+5,*q=NULL;
q=(p+5);
printf("%d %d \n",*p,q);
}
程序运行后的输出结果是( C )
A) 运行后报错
B) 6 6
C) 6 11
D) 5 10
96. 有以下程序
#include <stdio.h>
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);
}
程序的运行结果是( B )
A) 0
B) 1
C) 2
D) 3
97. 有以下程序
main()
{ int a=5,b=4,c=3,d=2;
if(a>b>c)
printf(”%d\n",d);
else if((c-1>=d)1)
printf("%d\n",d+1);
else
printf("%d\n",d+2);
}
执行后输出的结果是( B )
A) 2
B) 3
C) 4
D) 编译时有错，无结果
第一个IF 里面 判断 A>B>C 她不是一块判断的 而是从左到右进行判断 先判断A>B因为成立 所以A>B是正确的 所以A>B的值为 1
98. 若以下选项中的变量已正确定义，则正确的赋值语句是( C )
A) x1=26.8%3;
B) 1+2=x2
C) x3=0x12;
D) x4=1+2=3;
99. 在执行以下程序时,如果从键盘上输入,ABCdef<回车>,则输出是( B )
#include<stdio,h>
main()
{ char ch;
while((ch=getchar())!=’\n’)
{ if(ch>=‘A’ && ch<=‘Z’) ch=ch+32;
else if(ch>=‘a’ && ch<=‘z’) ch=ch-32;
printf("%c",ch);
}
printf("\n");
}
A) ABCdef
B) abcDEF
C) abc
D) DEF
100. 有以下程序
#include <string.h>
main()
{
char p[]={‘a’,‘b’,‘c’}, q[10]={‘a’,‘b’,‘c’};
printf("%d %d\n",strlen§,strlen(q));
}
以下叙述中正确的是
( A )
A) 在给p和q数组置初值时，系统会自动添加字符串结束符，故输出的长度都为3
B) 由于p数组中没有字符串结束符，长度不能确定；但q数组中字符串长度为3
C) 由于q数组中没有字符串结束符，长度不能确定；但p数组中字符串长度为3
D) 由于p和q数组中都没有字符串结束符，故长度都不能确定
101. 当变量c的值不为2、4、6时，值也为“真”的表达式是
( B )
A) (c2)||(c4)||(c6)
B) (c>=2 && c<=6)||(c!=3)||(c!=5)
C) (c>=2 && c<=6)&&!(c%2)
D) (c>=2 && c<=6)&&(c%2!=1)
102. 以下程序的输出结果是( A )
main()
{ int n=4；
while(n–)printf("%d “，–n)；
}
A) 2 0
B) 3 1
C) 3 2 1
D) 2 1 0
？103. 有以下程序：
main()
{ int x=102, y=012;
printf(”%2d,%2d\n",x,y); 012八进制=10
}
执行后输出结果是( C )
A) 10,01
B) 02,12
C) 102,10
D) 02,10
104. 以下程序的输出结果是
( C )
main()
{ int i, x[3][3]={1,2,3,4,5,6,7,8,9};
for(i=0;i<3;i++)
printf("%d,",x[i][2-i]);
}
A) 1,5,9
B) 1,4,7
C) 3,5,7
D) 3,6,9
105. 若有以下定义和语句:
char s1[ ]=“12345”,s2[ ]=“1234”;
printf("%d\n",strlen(strcpy(s1,s2)));
则输出结果是( A )
A) 4
B) 5
C) 9
D) 10
106. 以下不能定义为用户标识符是( D )
A) man
B) _0
C) _int
D) sizeof
107. 已知i、j、k为int型变量，若从键盘输入：1,2,3<回车>，使i的值为1、j的值为2、k的值为3，以下选项中正确的输入语句是( C )
A) scanf("%2d%2d%2d",&i,&j,&k);
B) scanf("%d %d %d",&i,&j,&k);
C) scanf("%d,%d,%d",&i,&j,&k);
D) scanf(“i=%d,j=%d,k=%d”,&i,&j,&k);
108. 下面程序段中，输出的“”的个数是( C )。
char *s= “\039\tcac”;
for( *s !=’\0’; s++) printf(" * “);
A) 9
B) 5
C) 6
D) 7
109. 有以下程序
point(char *p) { p+=3; }
main()
{ char b[4]={‘a’,‘b’,‘c’,‘d’}, *p=b;
point§;
printf(”%c\n",p);
}
程序运行后的输出结果是( B )
A) a
B) b
C) c
D) d
110. 设有 int x=11; 则表达式 (x++ * 1/3) 的值是( A )
A) 3
B) 4
C) 11
D) 12
111. 以下能正确定义一维数组的选项是( B )
A) int a[5]={0,1,2,3,4,5};
B) char a[]={0,1,2,3,4,5};
C) char a={‘A’,‘B’,‘C’};
D) int a[5]=“0123”; 数组定义不能字符串
112. 执行下述程序片段时的输出结果是( C )。
int x,y;
x=13;
y=5;
printf("%d",x%=(y/=2));
A) 3
B) 2
C) 1
D) 0
113. 以下程序执行后sum的值是( C ).
main()
{ int i , sum;
for(i=1;i<6;i++) sum+=i;
printf("%d\n",sum);}
A) 15
B) 14
C) 不确定
D) 0
114. 以下叙述中正确的是( D )
A) 输入项可以是一个实型常量,如:scanf("%f",3.5);
B) 只有格式控制,没有输入项,也能正确输入数据到内存,例如:scanf(“a=%d,b=%d”);
C) 当输入一个实型数据时,格式控制部分可以规定小数点后的位数,例如:scanf("%4.2f",&f);
D) 当输入数据时,必须指明变量地址,例如:scanf("%f",&f);
115. 有以下程序
main()
{
char a1=‘M’,a2=‘m’;
printf("%c\n",(a1, a2));
}
以下叙述中正确的是
( B )
A) 程序输出大写字母M
B) 程序输出小写字母m
C) 格式说明符不足，编译出错
D) 程序运行时产生出错信息
116. 若有说明：int a[10]; 则对a数组元素的正确引用是( D )
A) a[10]
B) a[3.5]
C) a(5)
D) a[10-10]
117. 请读下面的程序。
#include <stdio.h>
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);
}
上面程序的输出结果是( B )。
A) 7
B) 8
C) 9
D) 10
118. 有以下程序
#include <string.h>
main()
{ char p[20]={‘a’,‘b’,‘c’,‘d’},q[]=“abc”,r[]=“abcde”;
strcpy(p+strlen(q),r); strcat(p,q);
printf("%d %d\n",sizeof§,strlen§);
}
程序运行后的输出结果是
( C )
A) 20 9
B) 9 9
C) 20 11
D) 11 11
119. 以下程序的输出结果是
( D )
main()
{ int a=3;
printf("%d\n",(a+=a-=aa) );
}
A) -6
B) 12
C) 0
D) -12
120. 若有说明语句：int a,b,c,d=&c；，则能正确从键盘读入三个整数分别赋给变量a、b、c的语句是( A )
A) scanf("%d%d%d",&a,&b,d);
B) scanf("%d%d%d",&a,&b,&d);
C) scanf("%d%d%d",a,b,d);
D) scanf("%d%d%d",a,b,d);
121. 以下程序的功能是：给r输入数据后计算半径为r的圆面积s。程序在编译时出错。
main()
/ Beginning /
{
int r; float s;
scanf("%d",&r);
s=πrr;
printf(“s=%f\n”,s);
}
出错的原因是
( D )
A) 注释语句书写位置错误
B) 存放圆半径的变量r不应该定义为整型
C) 输出语句中格式描述符非法
D) 计算圆面积的赋值语句中使用了非法变量
122. 以下程序运行后,输出结果是( C )
func(int a, int b)
{ static int m=0,i=2;
i+=m+1;
m=i+a+b;
return(m); }
main()
{ int k=4,m=1,p;
p=func(k,m);printf("%d,",p);
p=func(k,m);printf("%d\n",p);
}
A) 8,15
B) 8,16
C) 8,17
D) 8,81
123. 语句printf(“a\bre’hi’y\\bou\n”);的输出结果是( C )(说明:’\b’是退格符)
A) a\bre\'hi\'y\\\bou
B) a\bre\'hi\'y\bou
C) re’hi’you
D) abre’hi’y\bou
124. 以下程序的输出结果是
( A )
main()
{ int a=0,i;
for(i=1;i<5;i++)
{ switch(i)
{ case 0:
case 3:a+=2;
case 1:
case 2:a+=3;
default:a+=5;
}
}
printf("%d\n",a);
}
A) 31
B) 13
C) 10
D) 20
125. 下面函数的功能是( A )
int funl(char * x)
{ char * y=x;
while(*y++);
return(y-x-1);}
A) 求字符串的长度
B) 比较两个字符串的大小
C) 将字符串x复制到字符串y
D) 将字符串x连接到字符串y后面
126. 设有定义：int a, *pa=&a; 以下scanf语句中能正确为变量a读入数据的是( A )
A) scanf("%d",pa);
B) scanf("%d",a);
C) scanf("%d",&pa);
D) scanf("%d",*pa);
127. 有以下程序
main()
{ int a=1, b=3, c=5;
int *p1=&a, *p2=&b, *p=&c;
*p=p1(*p2);
printf("%d\n",c);
}
执行后的输出结果是
( C )
A) 1
B) 2
C) 3
D) 4
128. 编制一个好的程序，首先要保证它的正确性和可靠性，还应强调良好的编程风格，在选择标识符的名字时应考虑( C )。
A) 名字长度越短越好，以减少源程序的输入量
B) 多个变量共用一个名字，以减少变量名的数目
C) 选择含义明确的名字，以正确提示所代表的实体
D) 尽量用关键字作名字，以使名字标准化
129. 请读程序：
#include<stdio.h>
main()
{ int a;
float b, c;
scanf("%2d%3f%4f",&a,&b,&c);
printf("\na=%d, b=%f, c=%f\n", a, b, c);
}
若运行时从键盘上输入9876543210(表示回车)，则上面程序的输出结果是( C )
A) a=98, b=765, c=4321
B) a=10, b=432, c=8765
C) a=98, b=765.000000, c=4321.000000
D) a=98, b=765.0, c=4321.0
130. 请读程序：
#include<stdio.h>
f(char s)
{ char p=s;
while( p!=’\0’) p++;
return(p-s);
}
main()
{ printf("%d\n",f(“ABCDEF”));}
上面程序的输出结果是( B )
A) 3
B) 6
C) 8
D) 0
131. 有以下程序
#include <stdio.h>
main()
{ int x=1, y=2, z=3;
if (x>y)
if (y<z) printf("%d", ++z);
else printf("%d", ++y);
printf("%d\n", x++);
}
程序的运行结果是( D )
A) 331
B) 41
C) 2
D) 1
132. 设变量x和y均己正确定义并赋值。以下if语句中，在编译时将产生错误信息的是
( A )
A) if (x++);
B) if (x>y && y!=0);
C) if (x>0) x–
else y++;
D) if (y<0) {;}
else x++;
133. 有以下程序
main()
{ int p[7]={11,13,14,15,16,17,18},i=0,k=0;
while(i<7&&p[i]%2){k=k+p[i]; i++;}
printf("%d\n",k);
}
执行后输出的结果是( D )
A) 58
B) 56
C) 45
D) 24
134. 对于下述for循环语句，说法正确的是( B )。
int i,k;
for(i=0,k=-1;k=1;i++,k++)
printf("");
A) 判断循环结束的条件非法
B) 是无限循环
C) 只循环一次
D) 一次也不循环
135. C语言源程序名的后缀是( B )
A) .exe
B) .C
C) .obj
D) .cp
136. 在C语言中，如果下面的变量都是int类型，则输出结果是( A )
sum=a=5;
a=sum++,a++,++a;
printf("%d\n",a);
A) 7
B) 6
C) 5
D) 4
137. 以下关于运算符优先顺序的描述中正确的是( C )
A) 关系运算符<算术运算符<赋值运算符<逻辑与运算符
B) 逻辑与运算符<关系运算符<算术运算符<赋值运算符
C) 赋值运算符<逻辑与运算符<关系运算符<算术运算符
D) 算术运算符<关系运算符<赋值运算符<逻辑与运算符
138. 下述语句中，( C )中的if语句语法是错误的。
A) if(x>y);
B) if(x==y) x+=y;
C) if(x!=y) scanf("%d",&x) else scanf("%d",&y);
D) if(x<y) {x++;y++;}
139. 以下程序的输出结果是( A )
include <stdio.h>
include <string.h>
main()
{ char str[12]={‘s’,‘t’,‘r’,‘i’,‘n’,‘g’};
printf("%d\n",strlen(str)); }
A) 6
B) 7
C) 11
D) 12
140. 若x为int型变量，y是float型变量，输入语句格式为：
scanf(“x=%d,y=%f”,&x,&y)
则为使x=20,y=166.6，正确的输入是( B )。
A) 20 166.6 <回车>
B) x=20,y=166.6 <回车>
C) 20 <回车> 166.6 <回车>
D) 20,166.6 <回车>
141. 有以下程序
#include <stdio.h>
#include<string.h>
main()
{ char str[ ][20]={“OneWorld”, “OneDream!”},p=str[1];
printf(“%d,”,strlen§);printf(“%s\n”,p);
}
程序运行后的输出结果是( C )
A) 9,OneWorld
B) 9,OneDream
C) 10,OneDream
D) 10,OneWorld
142. 以下程序运行后,如果从键盘上输入:
book <回车>
book <空格><回车>
则输出的结果是( B )
#include<string.h>
main()
{char a1[80],a2[80],s1=a1, s2=a2;
gets(s1); gets(s2);
if(! strcmp(s1,s2)) printf("");
else printf("#");
printf("%d\n",strlen(strcat(s1,s2)));
}
A) 8
B) #9
C) #6
D) 9
143. 若变量已正确定义，要求程序段完成求5!的计算，不能完成此操作的程序段是( B )
A) for(i=1, p=1; i<=5; i++) p=i;
B) for(i=1; i<=5;i++){ p=1; p=i; }
C) i=1; p=1; while(i<=5){ p=i; i++;}
D) i=1;p=1;do{p=i; i++; } while(i<=5)
144. 以下程序运行后,输出结果是( B )
main()
{
int y=18,i=0,j,a[8];
do
{ a[i]=y%2;
i++;
y=y/2;
} while(y>=1);
for(j=i-1;j>=0;j–) printf("%d",a[j]);
printf("\n");
}
A) 10000
B) 10010
C) 00110
D) 10100
145. 在一个C语言程序中( B )
A) main函数必须出现在所有函数之前
B) main函数可以在任何地方出现
C) main函数必须出现在所有函数之后
D) main函数必须出现在固定位置
146. 有以下程序
#include <stdio.h>
main()
{ int c=0,k;
for (k=1;k<3;k++)
switch (k)
{default: c+=k
case 2: c++;break;
case 4: c+=2;break;
}
printf(“%d\n”,c);
}
程序运行后的输出结果是( A )
A) 3
B) 5
C) 7
D) 9
147. 有以下程序
main()
{ char str[][10]={“China”,“Beijing”},p=str;
printf("%s\n",p+10);
}
程序运行后的输出结果是( B )
A) China
B) Beijing
C) ng
D) ing
148. 下列函数定义中，会出现编译错误的是( B )
A) max(int x, int y, int z)
{ z = x>y?x:y; }
B) int max(int x, y)
{
int z;
z = x>y?x:y;
return z;
}
C) max(int x, int y)
{
int z;
z = x>y?x:y;
return(z);
}
D) int max(int x, int y)
{ return (x>y ? x : y); }
149. 假定a和b为int型变量,则执行以下语句后b的值为( D )
a=1;b=10;
do
{b-=a;a++;}
while(b–<0);
A) 9
B) -2
C) -1
D) 8
150. 如果假设
a=2，b=3，x=3.5，y=2.5
那么下面的算术表达式的值是( B )。
(float)(a+b)/2+(int)x%(int)y
A) 2
B) 3
C) 3.5
D) 2.5
151. 以下程序段给数组所有的元素输入数据，请选择正确答案填入( D )
#include <stdio.h>
main()
{
int a[10],i=0;
while(i<10)
scanf("%d",______);
}
A) a+(i++)
B) &a[i+1]
C) a+i
D) &a[i++]
152. 以下选项中可作为C语言合法整数的是( C )
A) 10110B
B) 386
C) 0Xffa
D) x2a2
153. 有以下程序
main()
{ int i, s=0, t[]={1,2,3,4,5,6,7,8,9};
for(i=0;i<9;i+=2) s+=(t+i);
printf("%d\n",s);
}
程序执行后的输出结果是
( C )
A) 45
B) 20
C) 25
D) 36
三、多项选择题：
- 以下叙述中正确的是( BCD )
A) 用户所定义的标识符允许使用关键字 标识符中不允许与任何关键字同名
B) 用户所定义的标识符应尽量做到“见名知意”
C) 用户所定义的标识符必须以字母或下划线开头
D) 用户定义的标识符中，大、小写字母代表不同标识 - 下列定义变量的语句中正确的是( ABC )
A) int int;
B) double int;
C) char For;
D) float US$; $不属于字母、数字、或者下划线 - 设有定义：int k=1, m=2；float f=7;，则以下选项中符合C语言语法的表达式是
( ABD )
A) k=k>=k
B) -k++
C) k%int(f) %要求运算的对象都是int型，应该为 k%（int)f
D) k<>m - 若有定义语句：double x[5]={1.0,2.0,3.0,4.0,5.0}, *p=x;则正确引用x数组元素的是( ACD )
A) *p
B) x[5] 下标越界
C) *(p+1)
D) *x - 若要求定义具有10个int型元素的一维数组a，则以下定义语句中正确的是
( ABC )
A) #define N 10
int a[N];
B) #define n 5
int a [2*n];
C) int a[5+5];
D) int n=10,a[n]; 数组维数不能为变量 - C源程序中可以表示的数制是
( BCD )
A) 二进制
B) 八进制
C) 十进制
D) 十六进制 - 按照C语言规定的用户标识符命名规则，能出现在标识符中的是( ACD )
A) 大写字母
B) 连接符
C) 数字字符
D) 下划线 - 以下不合法的字符型常量是( B D )
A) ‘\x13’
B) ‘\081’ 八进制转义字符不能超过8
C) ‘\065’
D) “\n” 字符串不属于字符常量 - 以下合法的字符常量是
( BCD )
A) ‘\018’
B) ‘"’ 简单转义字符
C) '\ 简单转义字符
D) ‘\0xcc’ 十六进制转义字符 - 以下叙述中正确的是( ABD )
A) C语句必须以分号结束
B) 复合语句在语法上被看作一条语句
C) 空语句出现在任何位置都不会影响程序运行
D) 赋值表达式末尾加分号就构成赋值语句 - 以下合法的赋值语句是( ABD )
A) n=(i=2,++i);
B) j++;
C) ++(i+1); 自加自减运算只能用于变量，而不能用于常量和表达式
D) x=j>0; - 以下能正确定义二维数组的选项是
( AB )
A) int a[2][2] = {{1}, {2}};
B) int a[ ][2] = {1, 2, 3, 4};
C) int a[2][2] = {{1}, {2},{3}}; 第一维下标越界
D) int a[2][ ] = {{1, 2}, {3, 4}}; 不能省略第二维下标 - 若有定义：int aa[8]；则以下表达式中能代表数组元aa[1]的地址的是
( ABD )
A) &aa[0]+1
B) &aa[1]
C) &aa[0]++ 先赋值&aa[0]，再执行++，最后&aa[0]++= &aa[0]
D) aa+1 - 已有定义：int i,a[10],*p; , 则不合法的赋值语句是( ABC )
A) p=100;
B) p=a[5]
C) p=&a[2]+2
D) p=a+2; 指针p只能存放指向内存单元的地址，a+2可表示a[2]的地址 - 以下能正确进行字符串赋初值的语句是( BCD )
A) char str[5]=“good!”; 下标越界
B) char str[]=“good!”;
C) char *str=“good!”;
D) char str[5]={‘g’,’o’,‘o’,‘d’}; - 已知大写字母A的ASCⅡ码是65，小写字母a的ASCⅡ码是97。以下能将变量c中的大写字母转换为对应小写字母的语句是( ABC )
A) c=(c-‘A’)%26+‘a’
B) c=c+32
C) c=c-‘A’+‘a’
D) c=(‘A’+c)%26-‘a’ - 设有以下定义和语句
char str[20]=“Program”, *p;
p=str;
则以下叙述中错误的是( BCD )
A) *p与str[0]中的值相等
B) 可以执行p++操作
C) 可以执行str++操作
D) str数组长度和p所指向的字符串长度相等 - 对于下面①，②两个循环语句，正确的描述是(AB )。
① while(1);
② for( ; ; );
A) ①是无限循环
B) ②是无限循环
C) ①循环一次
D) ②循环一次 - 以下错误的函数定义形式是( BCD ) 函数定义没有分号；
A) double fun (int x , int y)
B) double fun (int x ; int y);
C) double fun (int x , int y) ;
D) double fun (int x , y) ; - 对于基本类型相同的两个指针变量之间，可以进行的运算是( ABD )
A) <
B) =
C) + 指针之间的加法没有任何意义
D) - - 能把字符串:Hello!赋给数组b的语句是( ACD )
A) char b[10]={‘H’,‘e’,‘l’,‘l’,‘o’,’!’};
B) char b[10];b=“Hello!”;
C) char b[10];strcpy(b,“Hello!”);
D) char b[10]=“Hello!”; - 以下能对二维数组a进行正确初始化的语句是( AD )
A) int a[2][3]={0};
B) int a[2][ ]={{1, 2}, {0}};
C) int a[2][3]={{1, 2}, {3, 4}, {5, 6}}; 第一维下标越界
D) int a[ ][3]={1, 2, 3, 4, 5, 6}; - sizeof(double)是 ( CD )
A) 一种函数调用
B) 一个双精度型表达式
C) 一个整型表达式
D) sizeof是运算符 单目运算符 - 设a为整型变量，能正确表达数学关系：10<a<15 的C语言表达式是( BC )
A) 10<a<15
B) a11||a12||a13||a14
C) a>10&&a<15
D) (a<10)||(a>15) 有一个为真则表达式为真 - C语言中基本的数据类型包括( ABD )
A) 整型
B) 实型
C) 逻辑型
D) 字符型 - 以下对一维整型数组y的错误定义是( ABC )。
A) int y(10);
B) int k=10,y[k];
C) int k;
D) #define SIZE 8
int y[SIZE]; size为常量 - 若已定义:int a[ ]={0,1,2,3,4,5,6,7,8,9}, *p=a,i;其中 0≤i≤9, 则对a数组元素正确的引用是( ABC )
A) a[p-a]
B) *(&a[i])
C) p[i]
D) a[10] 下标越界 - 若a、b、c、d都是int类型变量且初值为0，以下选项中正确的赋值语句是( ABD )。
A) a=b=c=100;
B) d++;
C) c+b; 变量之间不能直接进行运算
D) d=(c=22)-(b++); - 设有定义：char p[]={‘1’, ‘2’, ‘3’},*q=p; ，以下能计算出一个char型数据所占字节数的表达式是( ABC )
A) sizeof§
B) sizeof(char)
C) sizeof(*q)
D) sizeof(p[0]) sizeof是一种单目运算符，用来计算数组或者结构所需空间的大小 - 下列选项中，合法的C语言关键字是( BD )
A) VAR
B) char
C) integer
D) default - 若变量x、y已正确定义并赋值，以下不正确的表达式是( BD )
A) ++x,y=x–
B) x+1=y 左边必须是变量，不能是常量或者运算符结合起来的表达式
C) x=x+10=x+y
D) double(x)/10 - 以下定义语句中错误的是( AD )
A) int a=b=0; 相当于只对a进行了赋值
B) char A=65+1,b=‘b’;
C) float a=1,*b=&a,*c=&b;
D) double a=0.0;b=1.1; ；应该改为， - 已定义ch为字符型变量，以下赋值语句中正确的是( BCD )
A) ch=’’； \’’或\或\’才是简单转义字符，\后面必须跟一个字符或者八进制、十六进制数
B) ch=62+3；
C) ch=NULL；
D) ch=’\xaa’； - 下列选项中，正确的赋值表达式是( BC )
A) (a+b)++ 自加或者自减只能用于变量
B) n1=(n2=(n3=0))
C) k=i=j
D) a=b+c=1 1不能同时或者单独赋值给b，c - 以下叙述中错误的是
( ABd )
A) C程序中的注释只能出现在程序的开始位置和语句的后面
B) C程序书写格式严格，要求一行内只能写一个语句
C) C程序书写格式自由，一个语句可以写在多行上 C语言的语法限制不严格，可以多条语句放在同一行上，也可以将一条语句写在多行，故选项B)错误，
D) 用C语言编写的程序只能放在一个程序文件中 因为用C语言编写的程序可以放在不同的文件中，文件之间使用预处理命令进行调用。 - 指出下面正确的赋值语句( CD )
A) a++ 语句要有；
B) a==b; 关系运算符
C) a+=b;
D) a=1,b=1; - 下面正确的字符常量为( BD )。
A) “n” 字符串
B) ‘\’
C) ‘ab’ 错误引用
D) ‘u’ - 若程序中定义了以下函数：
double myadd(double a,double b)
{ return (a+b);}
并将其放在调用语句之后，则在调用之前应该对该函数进行说明，以下选项中正确的说明是( BCD )
A) double myadd(double a,b);
B) double myadd(double,double);
C) double myadd(double b,double a);
D) double myadd(double x,double y); - 下选项中是Ｃ语句的是( ABD )。
A) {int i; i++; printf(“%d\n”,i);}
B) ;
C) a=5,c=10
D) { ; } - 以下叙述中错误的是( ABC )
A) 预处理命令行必须位于源文件的开头 不一定
B) 在源文件的一行上只能有一条预处理命令 一行可以写多条语句
C) 宏名必须用大写字母表示 通常用大写字母表示，不是必须
D) 宏替换不占有程序的运行时间 - 设p1和p2是指向同一个int型一维数组的指针变量,k为int型变量,则能正确执行的语句是( CD )
A) k=*p1+*p2; 指针之间的加法没有意义
B) p2=k; int之间不能相互赋值，p2=&k;
C) p1=p2;
D) k=*p1 *(*p2); - 以下叙述中正确的是( ABD )
A) C程序必须由一个或一个以上的函数组成
B) 函数调用可以作为一个独立的语句存在
C) 若函数有多个返回值，必须通过多个return语句返回 只能返回一个值（静态变量除外）
D) 函数形参的值改变也可以传回给对应的实参 - 设有以下定义
int a=0; int *p=&a; char c=‘A’;
#define d 2
则下面语句中正确的是( ABC )
A) a++;
B) b++;
C) c++;
D) d++; d是常量，不能进行自加或者自减 - 关于形参和实参的说法中，错误的是( ACD )。
A) 形参是虚设的，所以它始终不占存储单元
B) 实参与它所对应的形参占用不同的存储单元
C) 实参与它所对应的形参占用同一个存储单元
D) 实参与它所对应的形参同名时可占用同一个存储单元 - 若有说明：int n=2,*p=&n,*q=p;，则以下正确的赋值语句是( ABC )
A) p=q;
B) *p=*q;
C) n=*q;
D) p=n; - 下列错误的C语言标志符的是( ACD )。
A) Aa+
B) __123
C) a*bc
D) b&cd - 以下叙述中正确的是( BCD )
A) 改变函数形参的值，不会改变对应实参的值 通过指针可以改变指向的内容
B) 函数可以返回地址值
C) 可以给指针变量赋一个整数作为地址值
D) 当在程序的开头包含头文件stdio.h时，可以给指针变量赋NULL - 下面正确的转义字符是( AC )。
A) ‘\101’
B) ‘’ \不属于转义字符，\’或\’’或\才属于
C) ‘\xaf’ 十六进制转义字符
D) ‘\018’ - 以下选项中，合法的字符常量是( AD )
A) ‘\t’
B) ‘\18’
C) “n” 属于字符串
D) ‘\xaa’ - 下列叙述中错误的是( AC )
A) break语句只能用于switch语句
B) 在switch语句中可以不使用default
C) break语句必须与switch语句中的case配对使用
D) 在switch语句中，不一定使用break语句 - 下面不能正确进行字符串赋值操作的是( ABC )
A) char s[5]={“ABCDE”};
B) char s[5]={‘A’,’B’,’C’,’D’,’E’}; 属于字符数组，但是不是字符串赋值语句
C) char *s; s= “ABCDE”;
D) char *s; scanf(“%s”, s); s指向的内存空间是随机的，不是合法的内存空间 - t为int类型，进入下面的循环之前，t的值为0
while( t=l )
{ …… }
则以下叙述中正确的是( BD )
A) 循环控制表达式的值为0
B) 循环控制表达式的值为1
C) 循环控制表达式不合法
D) 该循环为死循环 - 下面正确的字符串常量是( BC )
A) ‘abc’ 单引号只能引起一个字符
B) “1212”
C) “aaa”
D) “” - 若有说明：int a[3][4]; 则不能对a数组元素的正确引用是( ABD )。
A) a[2][4]
B) a[1, 3]
C) a[1][0]
D) a (2)(1) - 以下选项中合法的标识符是
( ABD )
A) print
B) FOR
C) &a
D) _00 - 以下数组定义中正确的是( ABC )
A) int a[2][3];
B) int b[][3]={0,1,2,3};
C) int c[100][100]={0};
D) int d[3][]={{1,2},{1,2,3},{1,2,3,4}}; - 下列选项中，能用作标识符的是( AC )
A) 1234
B) a-2
C) int_2_
D) 2_int_ - 以下为无限循环的语句或语句组是
( BCD )
A) n=0;
do {++n;} while (n<=0); 表达式为假，直接跳出循环
B) n=0;
while (1) {n++;}
C) n=10;
while (n);
{n–;}
D) for (n=0, i=1; ; i++) n+=i; - 以下不能正确定义二维数组的是
( BD )
A) int a[2][3];
B) int a[][3]={2*3};
C) int a[][3]={};
D) int a[2][3]={{1},{2},{3,4}}; 下标越界 - 下列标识符中合法的是( BC )。
A) student-name
B) _name
C) name8
D) 3_DS - 以下选项中，合法的常量是( ACD )
A) 1.234e04
B) 1.234e0.4 e后面的数字只能为int
C) e+4
D) 1.234e-2 - 设有如下程序段
char s[20]=“Beijing”, p;
p = s;
则执行p=s;语句后，以下叙述错误的是( BCD )
A) 可以用p表示s[0]
B) s数组中元素的个数和p所指字符串长度相等 S为8，p为7
C) s和p都是指针变量 s不是
D) 数组s中的内容和指针变量p中的内容相同 - 以下定义语句中错误的是( ABD )
A) char a=‘A’ b=‘B’; 中间要用逗号隔开
B) float a=b=10.0;
C) int a=10,*b=&a;
D) float *a,b=&a; b不是指针对其赋值不需要取地址& - 以下合法的用户标识符是
( ABD )
A) j2_KEY
B) Double
C) 4d
D) 8 - 已定义c为字符型变量，则下列语句中错误的是
( BCD )
A) c = ‘97’; 字符的赋值要用单引号
B) c = “97”;
C) c = 97;
D) c = “a”; - 若有以下程序
#include <stdio.h>
void f(int n);
main()
{ void f(int n);
f(5);
}
void f(int n)
{ printf("%d\n",n); }
则以下叙述中正确的是( ABD )
A) 若只在主函数中对函数f进行说明，则只能在主函数中正确调用函数f
B) 若在主函数前对函数f进行说明，则在主函数和其后的其它函数中都可以正确调用函数f
C) 对于以上程序，编译时系统会提示出错信息：提示对f函数重复说明
D) 函数f无返回值，所以可用void将其类型定义为无值型 - 若x和y代表整型数，以下表达式中能正确表示数学关系|x-y|<10的是( ABD )
A) abs(x-y)<10
B) x-y>-10 && x-y<10
C) !(x-y)<-10 || !(y-x)>10
D) (x-y)*(x-y)<100 - 若已定义：int a[9]，*p=a；并在以后的语句中未改变p的值，能表示a[1]地址的表达式是( ABD )
A) p+1
B) a+1
C) a++
D) p[1] - 下列函数定义中，完全正确的是( ACD )
A) max(int x, int y, int* z)
{ *z = x>y?x:y; }
B) int max(int x, y)
{
int z;
z = x>y?x:y;
return z;
}
C) max(int x, int y)
{
int z;
z = x>y?x:y;
return(z);
}
D) int max(int x, int y)
{ return (x>y ? x : y); } - 请选出可以作为C语言用户标识符的一组标识符号
( AB )
A) void define WORD
B) a3_b3 _123 IF
C) for －abc case
D) 2a D0 size - 对函数嵌套的叙述中，错误的叙述为( ACD )。
A) 函数定义可以嵌套，但函数调用不能嵌套
B) 函数定义不可以嵌套，但函数调用可以嵌套
C) 函数定义和调用均不能嵌套
D) 函数定义和调用均可以嵌套 - 设有语句：int a=1,b=2,*p1=&a,*p2=&b; 以下不能使指针p1指向变量b的赋值语句是( ABD )。
A) p1=*p2
B) *p1=p2
C) p1=p2
D) *p1=*p2 - 以下不能正确定义字符串的语句是( AC )
A) char str[]={’\064’};
B) char str[]="\x43";
C) char str=’’;
D) char str[]="\0"; - 判断字符串s1是否大于字符串s2，不能达到目的的是( ABC )
A) if (s1>s2)
B) if (strcmp (s1, s2))
C) if (strcmp (s2, s1)>0)
D) if (strcmp (s1, s2)>0) - 若变量已正确定义并赋值，下面不符合C语言语法的表达式是(A D )
A) a:=b+1
B) a=b=c+2
C) (int)18.5%3
D) a=a+7=c+b - 下列语句中不符合C语言语法的赋值语句是( CD )。
A) x=(3+b,z)=x+3;
B) x=7+y,y++,z++;
C) x=y+2=x+y+z;
D) x=3+y++=x+3; - 设c1,c2均是char类型变量，则以下正确的函数调用为( AD )。
A) printf("%c,%c",c1,c2);
B) getchar(c1);
C) putchar("");
D) putchar(c1); - 以下所列的C语言常量中，正确的是( ACD )
A) 0xFF
B) 1.2e0.5
C) 2L
D) ‘\72’ - 下列选项中错误的语句是( AC )
A) char s[8]；s={“Bei jing”}； 下标越界
B) char s[8]={“hello”}；
C) char s[8]=“Bei jing!” 下标越界
D) char *s；s =“Bei jing”； - 若已定义的函数有返回值，则以下关于该函数调用的叙述中正确的是( ABC )
A) 函数调用可以作为独立的语句存在 无返回值时，也能作为独立语句
B) 函数调用可以作为一个函数的实参
C) 函数调用可以出现在表达式中
D) 函数调用可以作为一个函数的形参 函数值存在寄存器中，没有地址不能作为形参 - 已知ch是字符型变量，下面错误的赋值语句是( ACD )。
A) ch=”\”; 字符串标量
B) ch=’\xff’;
C) ch=’123’; ch=’\123’
D) ch=’\08’; - 下面各语句行中，不能正确进行赋字符串操作的语句行是( ABD )
A) char st[]={“ABCDE”};
B) char s[5]={‘A’,‘B’,‘C’,‘D’,‘E’};
C) char *s; s=“ABCDE”;
D) char *s; scanf("%s",s); - 以下正确的定义语句是( ABD )
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[4][]={{1, 2, 3}, {1, 2, 3}, {1, 2, 3}, {1, 2, 3}}; 不能省略第二维下标
D) int x[][3]={1, 2, 3, 4}; - 以下数组定义中正确的是( ACD )
A) int x[][3]={0};
B) int x[2][3]={{1,2},{3,4},{5,6}}; 下标越界
C) int x[][3]={{1,2,3},{4,5,6}};
D) int x[2][3]={1,2,3,4,5,6}; - 以下叙述中正确的是( ABD )
A) C语言是一种结构化程序设计语言
B) 结构化程序由顺序、分支、循环三种基本结构组成
C) 使用三种基本结构构成的程序只能解决简单问题
D) 结构化程序设计提倡模块化的设计方法
如果有喜欢好看的各种类型的壁纸、头像、朋友圈背景图、QQ名片背景图的朋友可以关注我个人公众号呀
每天分享超好看的各种风格类型 头像！壁纸！朋友圈背景图！嘿嘿！
关注我的公众号：壁纸头像爱好家
