C语言错题整理

1.如：int a=10,b=6,c;

       如果c=a/b；

       此时的c=1，因为整型的除法不是四舍五入，只保留小数位之前的数。

2.A&&B：当A(非零值)是真，且B(非零值)是真，才会返回1，表示真；否则，返回0，表示假。

   A||B:当A(非零值)是真，或者B(非零值)是真，会返回1，表示真；否则，返回0，表示假。

  ！A，将A取反，假设A的值或者表达式为真，则表示假。

3.f=(1,2,3),(4,5,6)

运行后f的值为3，因为在一对圆括号内并且用逗号分割时，取值只取最后一个元素，值为3；

并且赋值取的是逗号左边的表达式和值，因此后一个圆括号不做考虑。

4.（double）（20/3）

解法为先计算20/3取整为6，再强制转换为double类型，答案为6.0。

5.ch='a+b'是错的。

因为字符只能保存单个值，而ch='a'+'b'是正确的。

6.已知a为整型变量，那么与表达式 a!=0 真假值情况不同的表达式是( D ) 

A）a>0||a<0     B） a     C）!a==0     D） !a

表达式 a!=0 ，如果a本身为0，a!=0逻辑为假。如果a为非0值，a!=0为真

A：||是左右两边其中一个是真，那么表达式就为真。

B：a本身不为0，所有非零值即视为真。

C：左边是取反操作，所有非零值的反向逻辑值都是0，而==是判断，0肯定等于0，所以逻辑为真。

D：情况与a!相反

7.x=j>0成立

j>0可以看作是判断真假，返回1或0。

8.已有定义int x=3,y=4,z=5;则表达式 !(x+y)+z-1&&y+z/2的值是？

①括号内先运算：！7+5-1 && 4+5/2

②！7，为真，取反为0： 0+5-1 &&4+5/2

③化简计算：4 && 6

&&两边都为真，返回1。

9.逻辑运算符运算对象的数据类型是（）

——>任何类型的数据。

10.能正确表示X的取值范围在[0,100]和[-10,-5]内的表达式是

[-10,-5]：x>=-10&&x<=-5

[0,100]：x>=0&&x<=100

虽然是在[0,100]和[-10,-5]内，但是中间用||分开，因为不可能会同时取两者的值

11.以下程序的运行结果是：

int main(){

int c,x,y;

x=1;y=1;c=0;

c=x++||y++;

printf("%d%d%d/n",x,y,c);

}

——>2,1,1

从c=x++||y++;这一句来看，中间用||分割，首先考虑x++是否为真，x++不为0，真，x=x+1=2,c=1。

由于x++判断为真，所以y++并没有执行，y还是等于1。

12.以下程序的运行结果是：

int main(){

int c,x,y;

x=0;y=0;c=0;

c=x++&&y++;

printf("%d%d%d/n",x,y,c);

}

——>1，0，0

由于符号为&&，执行x++，x为0，返回假，x=x+1=1

13.以下程序的运行结果是：

int main(){

int x=y=1;

z=x++-1;

printf("%d%d",x,z);

z+=-x+++(++y||++z);

printf("%d%d%",x,z);

}

——>2,0,3,-1

①z=x++ -1，x++由于x的值是后增加的，此时x为1，z=1-1=0。

②z+=-x+++(++y||++z)，首先看括号内的++y，真，返回1，++z，z=0，假，返回0，由于||关系，返回1。

所以-x++ +1，此时x=2,-2+1=-1,z=z+-1=-1,x执行过x++后，此时x的值为3。

14.与条件表达式(n)?(c++):(c--)中的表达式(n)等价的表达式是（）

——>n!=0

条件表达式实际上就是if语句

if(n) ——实际上n为真，n不为零

    c++;

else

    c--;

n!=0，n不等于零，所以两者等价。

15.表达式sizeof(double)是（）

——> int型表达式

不能被double误导，实际上sizeof()是一个运算符号返回的是字节长度，返回值为int类型，所以是int型表达式。

16.已知：char a;int b;float c;double d;则执行语句c=a+b+c+d;后，变量c的数据类型是 （）

——>float

①语句c=a+b+c+d;根据计算类型转换，在计算中确实被转换为double类型进行计算。

②由于c被声明为float类型，所以返回值被返回为float类型的值。

17.若已知a=10，b=10，则表达式!a

——>1

①根据C语言运算符顺序，！比<优先，先计算！a,为假，返回0

②0

18.语句printf("a\bre\'hi\'y\\\bou");的输出结果是（）

——>re'hi'you

最大错误是把特殊字符看作斜杠和字符。

①实际上可以分解为a,\b,r,e，\',h,u,\',y,\\,\b,o,u

②很容易理解\b为退格符，\'为单引号，\\为\

③因此a被退格删除，\被退格删除，输出结果

19.若有以下程序段：int c1=5,c2=3,c3;c3=12.0/c1*c2;则执行后，c3中的值是（）

——>7

错误想法：①c1*c2=15②c3=12.0/15=0

实际上，c语言从左到右进行运算，因此在这个情况下先除再乘

12.0/5*3，计算出结果后再保存为int类型，所以答案为7

20.在C语言中，要求所有变量，遵循先定义后 使用 的原则

21.有符号的整型常量可以分为 int、short、 long、 longlong

22.在C语言中，实数有两种表现形式 指数形式、小数形式

23.int型的取值范围  16位：-32768，32767 32位：-2147483648,  2147483647

24.在C语言中，加减乘除这些运算符需要两个运算对象，称为 双目 运算符

25.罗技运算符的优先级是 ！ 高于 && 高于 ||

26.表示“整数x的绝对值大于5”的C语言表达式是 x<-5||x>5

27.设x=2.5,a=7,y=4.7,求下面算数表达式的值：x+a%3*(int)(x+y)%2/4;

——>2.5

①2.5+7%3*(int)(2.5+4.7)%2/4;

②2.5+7%3*7%2/4;    

③2.5+1*7%2/4; //计算按照从左往右，想当然的先计算3*7导致的错误

④2.5+7%2/4;

⑤2.5+1/4;

⑥2.5+0=2.5

28.表达式5%(-3)的值是（）表达式-5%-3的值是（）

——>2，-2

5%(-3)，取-1，余2

-5%-3，取1，余-2

29.设变量r的值为某个角度的值，则其弧度的表达式是 r*3.1415926/180

30.若x为int类型，请以最简单的形式写出与逻辑表达式！x等价的C语言表达式 x==0

31.以下程序的运行结果是（）

——>333

#include

int main(){

int x1=0xabc,x2=0xdef;

x2-=x1;

printf("%x\n",x2);

return 0;

}

十六进制字母不区分大小写,A-F为10-16

x1为16进制abc即为十进制2748

a*16的2次方，b*16的1次方，c*16的0次方

x2为16进制def即为十进制3567

d*16的2次方，e*16的1次方，f*16的0次方

x2-x1为819,转换16进制即为333

819%16=333

printf("%X.."....)中%X表示十六进制输出，默认不输出0x

32.已知有如下定义和输入语句，若要求a1,a2,c1,c2的值分别为10，20，A，B，正确的数据输入为（）

——>scanf("%d%c %d%c",&a1,&c1,&a2,&c2); //因为%c字符类型会读入空格，之间不能空格

int a1,a2;

char c1,c2;

printf("%d%d%c%c",a1,a2,c1,c2);

33.写出程序的运行结果（）

——>a=374 a=0374

——>a=fc a=0Xfc

int main(){

int a=282;

printf("a=%o a=%#o\n",a,a);

printf("a=%x a=%#x\n",a,a);

}

解释：因为%o格式符输出八进制，#表示输出完整八进制位数；同理,%x输出十六进制，#表示输出完整十六进制位数

34.scanf处理输入数据时，遇到以下情况该数据认为结束  空白字符 、 非法字符 、 已读完要求位数。

35.int a=1234;printf("2d\n",a);

——>1234

解释：%2d，输出整形格式数据，2表示位宽，不足2位时用0补足。因为a明显超过2位位宽，所以直接输出1234。

如果是scanf("2d\n",a);输入的是1234，会出现截取，此时a=12

%-2d

输出2位位宽数据，若字符串本身长度大于2，则将数字全部输出，若数字本身长度小于2，则在右边补上空格

%e：e表示10的N次方，默认输出有效数字7位，1位是整数，6位小数，指数3位（不足3位时填0）。

printf("%e\n"，123.54) 结果为1.235400e+002

36.写出程序的运行结果（）

int main( ){

char c1='6',c2='0';

printf("%c,%c,%d,%d\n",c1,c2,c1-c2,c1+c2);

}

——>6,0,6,102

解释：c1-c2='6'-'0'=6;实际上不是数值的计算，而是ASCII码的运算。

‘6’的ASCII码是54，而‘0’是48,53-48=6，而输出的数值所以是6。

c1+c2=54+48=102

37.在scanf函数的格式的控制中，格式说明的类型与输入的类型应该一一对应匹配。如果类型不匹配，则系统（）

——>并不给出错误信息，但不可能得出正确信息数据

38.写出程序的运行结果（）

int main( ){

long y=-34567;

printf("%-8ld\n",y);

printf("%-08ld\n",y);

printf("%08ld\n",y);

printf("%+8ld\n",y);

}

——>y=-34567

——>y=-34567

——>y=-0034567

——>y=  -34567

解释：无符号表示右对齐，“-”号表示左对齐，“+”号表示在数字前面添上数字的符号。“0”表示对空白字段填充“0”，默认填充空格

1.-34567，一共5位数字+一个符号，6个宽度；-8，8位宽度并左对齐，-34567空格空格，由于换行所以空格"隐形"了

2.-08，对空白字符填充0，但因为左对齐，所以没有填充0

3.08，缺省，是右对齐，负号后面空出两个空格，因为用0填充，所以-0034567

4.+8，右对齐，+表示符号是填上的，用空格填充，空格空格-34567

39.写出程序的运行结果（）

int main( ){

int a=5,b=0,c=0;

if(a=b+c)

    printf("***\n");

else

    printf("$$$\n");

}

解释：if(a=b+c)，a=b+c是一个赋值语句，它返回的值为a的值为0

40.设有程序片段如下：

switch(class)

case 'A':printf("GREAT!");

case 'B':printf("GOOD!");

case 'C':printf("OK!");

case 'D':printf("NO!");

default:printf("ERROR!");

若class值'C',输出的结果是（）

——>OK!NO!ERROR!

解释：没有break语句所以一直从case 'C'执行下去，注意的是default也被执行

41.得到整型变量a的一个正整数的数字位表达式为（）

——>a/10%10

拓展：个位：a%10；十位：a/10%10；百位a/100%10；千位a/1000%10；

42.int i=1;则执行语句while(i++<4);后变量i的值为（）

——>5

①while(1++<4)②while(2++<4)③while(3++<4)④while(4++<4)不满足循环条件，i=4++=4+1=5

42.写出程序的运行结果（）

int main( ){

int y=10;

while(y--)

    printf("y=%d",y);

——>y=-1

①y=10,y--,y=9 ... ②y=0,y--,y=-1

43.若变量已正确定义，要求程序完成5!的计算，不能完成此操作的程序是（）

——>for(i=1;i<=5;i++){p=1;p*=i;}

解释：一个正整数的阶乘所有小于及等于该数的正整数的积，那么5！=1*2*3*4*5

而p=1在循环中导致每次p都被初始化为1，到最后只能p=1*5

44.int k=-20;while(k=0) k=k+1;循环体执行了几次（）

——>循环体语句一次也不执行

解释：while(k=0),k=0赋值，k为0，循环终止

45.定义如下变量：int n=10; 则下列循环的输出结果是（）

while(n>7){

n--;

printf("%d\n",n);

}

——>10

——>9

——>8

——>7

46.当输入为quert?时，下面程序的执行结果是（）

int main(){

while(putchar(getchar()))!='?');}

——>quert?

解释：putchar()里嵌套了getchar()读取字符，当读到？的时候读取结束，正好全部读完

47.C语言浮点数：①十进制小数②指数：e或E之前有数字，后面必须为整数

48.关于long、int、short型的数据占用内存大小的描述，正确的是（）

——>由C语言编译系统决定

49.若有说明：int a[10];则对a数组元素的正确引用是（）

——>a[10-10]

解释：a[10-10]等价于a[0]

50.将一个空格赋给字符变量c，正确的赋值语句是（）

A)c='\0'    B)c=NULL    C)c=0    D)c=32

——>D

解释：空格字符的ACSII码为32

51.\x后为1-2位十六进制

52.设C语言编译系统中，一个short型数据在内存中占两个字节，则unsigned short 型数据的取值范围为（）

——>0-65535

解释：unsigned无符号，最大的二进制数据为16个1：2的16次方-1

53.写出程序的运行结果（）

int main(){

int a=3,b=2,c=1;

c=5?a++:b--;

printf("%d",c);

}

——>3

解释：c=5?，为真，a++,c为3

54.单目运算符高于双目运算符，算数运算符高于关系运算符，关系运算符高于逻辑运算符

55.若有如下定义：int a=0,b=3,c=4,则表达式a&&b||c的值是（）

——>1

解释：a为假，a&&b为假。c为真，返回1。

56.若变量a是整型，则逻辑表达式(a==1)||(a!=1)的值是（）

——>1

解释：a==1,a!=1，所有的整型数的满足条件，所以一定为真

57.设有定义：int i=0;以下选项的4个表达式中与其他3个表达式的值不相同的是

A)i++    B)i+=1    C)++i    D)i+1

——>i++

解释：i++虽然也是i+1，但是是后增的，可能会影响结果

58.写出程序的运行结果（）

int main(){

int n=0,m=1,x=2;

if(!n)x=-1;

if(m)x=x+1;

if(x)x=-3;

printf("%d\n",x);

}

——>0

解释：if(!n)为真，x=-1;if(m)为真，x=x+1=-1+1=0;if(x)，为假

59.写出程序的运行结果（）

int main(){

int a=0;

a=(int)((double)(3/2)+0.5+(int)1.2*2);

printf("%d\n",a);

——>3

解释：①先看括号内(double)(3/2)=1.5;②1.5+0.5+(int)1.2*2=1.5+0.5+1*2=3③a=(int)3

60.下列描述不正确的是（）

A)字符型数组可以存放在字符串中

B)可以对字符型数组进行整体输入输出

C)可以对整型数组进行整体输入输出

D)不能在赋值语句中通过赋值运算符=对字符型数组进行整体赋值

——>C

61.写出程序的运行结果（）

int main(){

int k;

int a[3][3]={1,2,3,4,5,6,7,8,9};

for(k=0;k<3;k++)

    printf("%d",a[k][2-k]);

}

——>357

解释：数组a[3][3]，是一个3行3列的二维数组。第一行从a[0][0]=1起，至a[0][2]=3为止，3个元素。

根据循环，输出的是a[0][2],a[1][1],a[2][0]三个数，找到对应下标的数。

1，2，3

4，5，6

7，8，9

62.设有数组定义：char a[]="android";则数组a所占的空间为（）个字节。

——>8

解释：android，共有7个字符，因为没有定义数组长度，再加上是双引号声明的，默认有一个‘\0’字符，所以所占空间为8个字节。

63.若要求定义具有10个int型元素的一位数组a,则下列定义语句可能错误的是（）

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];

——>D

解释：A)B)C选项，实际都给数组声明了一个确定的空间大小。而D)选项，n是一个int 型变量，实际上还需要调用n的值才可以确定空间，无法直接给数组赋值，只好使用循环等方式赋初值。

64.下列字符数组str不能作为字符串使用的是（）

——>char str[8]={'s','h','a','n','g','h','a','i'};

解释：字符数组保存的是单个字符，而字符串定义为char str[]="shanghai",或者char str[]={"shanghai"};

65.已有定义：char a[]="xyz",b[]={'x','y','z'}以下描述正确的是（）

——>a数组大于b数组长度

解释：a的长度为3个字符加上一个'\0'符号为4，b长度为3个字符

66.引用数组元素时，其数组下标的数据元素类型允许是（）

——>整型常量或整型表达式

解释：数组下标为整型

67.若有说明int a[][4]={0,0},则下列叙述不正确的是（）

——>只有元素a[0][0]和a[0][1]可得到初值0，其余元素均得不到初值

解释：数组a所有元素默认初值都为0，而｛0，0｝只是a[0][0]和a[0][1]的值被指定为0

68.假设array是一个有10个元素的整型数组，则下列写法中正确的是（）

——>array[0]=10;

解释：array[0]=10;是正确的赋值语句，十个元素只是前提条件。另一个选项array[10]=0，array的元素只有十个,定义时为arrary[9]，超过了下标数字的长度所以错误。

69.下列字符串赋值语句中，不能正确把字符串“prog”赋给数组的语句是（）

——>char a[10];a="prog";

解释：正确的赋值语句是a[10]="prog"

70.二维数组的初始化

例如，对整型二维数组a[3][2]赋值

方法一：在定义的同时赋值

int a[3][2]={0};//所有数组元素均为0

方法二：

int a[3][2]={1,2,3,4,5,6};//常规的赋值方法

方法三：

int a[3][2]={{1,2},{3,4},{5,6}};//分行的赋值方法

方法四：

int a[3][2]={{1,2},{0},{3}};//部分赋值方法，第一行元素的值分别为1，2，第二行元素值都是0，第三行第一个元素值为3，第二个元素值为0

方法五：

int a[3][2];/先定义
for(i=0;i<=3;i++) //用双重for循环赋值，i，j表示二维数组下标
   for(j=0;j<=2;j++)

         scanf("%d",&a[i][j]);

71.数组名命名规则和变量名相同，遵循（）命名规则

——>标识符

72.在C语言中，引用数组元素通过 （）和（）来实现

——>数组名，下标

73.在C语言中，数组名被当作常量，其值是数组的（）

——>首地址

74.下列正确的函数形式是（）

——>float fun (int x, int y)

解释：函数定义不需要加；

75.写出程序的运行结果（）

int f(){static int i=0;int s=1;s+=i;i++;return s;}

int main(){
int i,a=0;
for(i=0;i<5;i++)
    a+=f();

printf("%d\n",a);

——>15

解释：f()中的i是static，静态局部变量，所以每次调用函数之后f()中的i并不被销毁。

每次调用函数时s都重新变为1，又因为s+=i在i++之前，所以每次都是1+前一次i的值，所以a=1+2+3+4+5=15

76.写出程序的运行结果（）

fun(int a[4]){

int k;

for(k=0;k<3;k++)

a[k+1]+=a[k];

return a[0];

}

int main (){

int a[4]={1,2,3,4};

fun(a);

printf("%d",a[3]);}

——>10

解释：fun(a);将数组a传递了过去，经过for循环，将数组a返回到main函数内，此时a[3]的值为10

77.在C语言程序中，当调用函数时（）

——>利用形参可以改变实参变量的值

78.如下程序的输出结果（）

long fib(int n){

if(n>2) return fib(n-1)+fib(n-2);

else return (2);}

int main(){

printf("%d\n",fib(3));

}

——>4

解释：fib(3)，n>2，所以return fib(2)+fib(1);

fib(2)，进入else，return 2；

fib(1)，进入else，return 2;

所以fib(3)=2+2=4;

79.以下在使用时，才为该类型变量分配内存的存储类说明是（）

——>auto和register

80.以下错误的描述是：函数调用可以（）

——>作为一个函数的实参

81.下面函数调用语句中实参的个数为（）

func((exp1,exp2),(exp3,exp4,exp5))

——>2

解释：括号内部是逗号语句，实参为最后一个逗号的数据，exp2和exp5,所以实参有2个

82.有如下定义的函数

fun(a) {printf("%d",a);}

则该函数的返回类型是（）

——>语法错误

解释：形参没有定义类型

82.以下函数值的类型是

fun(float x){float y;y=3*x-4;return y;}

——>int

解释：函数定义时未给出类型，默认为int型

83.在C语言中，说法中正确的是（）

——>函数的内部和外部定义的变量同名是合法的

84.设函数fun的定义形式如下：

void fun (char ch,float x){...}

则以下对函数fun的调用语句中，正确的是（）

A)fun("abc",3.0) ;   B)t=fun('D',16.5) ;    C)fun('65',2.8) ;    D)fun(32,32) ;

——>D

解释：fun(),第一个参数为字符，排除A选项；由于fun函数没有返回值，B选项是错误的；C选项'65'不是一个字符

85.一个函数一般由两个部分组成，他们是（）和（）

——>函数首部，函数体

86.返回语句的功能是从（）返回至（）

——>函数内部，调用处

87.最大公约数、最小公倍数的定义

最大公约数：指某几个整数共有因子中最大的一个。

如：12和30的公约数有：1、2、3、6，其中6就是12和30的最大公约数。

最小公倍数：公倍数的乘积

如：12和18的公倍数有：2、3、2、3，其中最小公倍数为2*3*2*3=36。

88.四舍五入取整语句：int(a+0.5)；

89.写出程序的运行结果（）

int a=5;int b=7;

int main(){

int a=4,b=3,c;

c=plus(a,b);

printf("A+B=%d",c);

}

plus(int x,int y){int z; z=a+b;return(z);}

——>A+B=12

解释：出现错误的是a,b的参数，实际上plus(a,b)调用的是main函数外部定义的a和b的值。

因为a和b只出现在外部中，而main函数内部的a和b作为x和y的参数。

90.下面程序执行和输出的结果是（）

#define Fan(a) a*a+1

int main(){

int m=2,n=3;

printf("%d\n",Fan(1+m+n));

}

——>12

解释：调用输出语句，1+m+n*1+m+n+1，因为a*a没有括号，所以导致输出结果为12

91.下面程序执行和输出的结果是（）

#define SQR(x) x*x

int main(){

int a=16,k=2,m=1;

a/=SQR(k+m)/SQR(k+m);

printf("%d\n",a);

}

——>2

解释：宏是文本替换并不是函数计算，①a=a/(SQR(K+M)/SQR(K+M));②a=a/(2+1*2+1/2+1*2+1);③a=15/7=2

92.有下面程序，执行语句后sum的结果是（）

#define ADD(x) x+x

sum=ADD(1+2)*3;

——>10

解释：sum=1+2+1+2*3=4+6=10

93.以下程序的输出结果是（）

#define Max(x,y) (x)>(y)? (x):(y)

int main(){

int a=5,b=2,c=3,d=3,t;

t=Max(a+b,c+d)*10;

printf("%d\n",t);

}

——>7

解释：①t=(a+b)>(c+d)?:(a+b):(c+d)*10;实际上如果c+d>a+b，为(c+d)*10

②t=a+b=7

94.阅读下面程序，写出运行结果（）

#define M (y*y+3*y)

int main(){

int s,y;

y=2;s=3*M+4*M+5*M;printf("s=%d\n",s);

}

——>120

解释：不能看成M（）函数，而是M的值为(y*y+3*y)

所以s=3*(y*y+3*y)+4*(y*y+3*y)+5*(y*y+3*y)=30+40+50=120

95.设有定义char a[10];要想从键盘输入一个字符给a,应使用（）

——>gets(a);

96.在一个源程序文件中定义的全局变量，其默认有效范围（）

——>从定义变量的位置开始到源程序文件结束

97.设函数有整型变量n,在未赋值的情况下其初值为0，则该变量的存储类别是（）

——>static

解释：static的初值为0

98.以下程序的运行结果是（）

#include

#include

int f(int a[],int n)

{if(n>0) return a[0]+f(a+2,n-2);

else return a[0];

}

int main(){

int b=[8]={1,2,3,4,5,6,7,8};

s=f(b+2,4);

printf("%d",s);

}

——>15

解释：s=f(b+2,4);传入的数组为{3,4,5,6,7,8};

①n=4,n>0,a[0]+f(a+2,n-2);传入的数组为}{5,6,7,8}

②n=2,n>0,a[0]+f(a+2,n-2);传入的数组为}{7,8}

③n=0，else,a[0]=7

④递归调回②，a[0]=5

⑤递归调回①，a[0]=3

s=3+5+7-15

99.以下正确的叙述是（）

——>宏替换不占用运行时间，只占用编译时间

100.以下不正确的叙述是（）

——>宏名必须用大写字母表示

101.以下正确的叙述是（）

——>凡是C源程序中以#标识的控制行都是预处理命令

102.在文件包含预处理语句（#include）的使用形式中，当文件名用双引号括起时，寻找被包含文件的方式是（）

当文件名用<>括起时，寻找被包含文件的方式是（）

——>现在源目录搜索，再按系统设定的标准方式搜索

——>直接用系统设定的标准方式搜索

103.阅读下面程序，写出运行结果（）

#define Min(x,y) (x)<(y)?(x):(y)

int main(){

int i,j,k;

i=10;j=15;

k=10*Min(i,j);

printf("%d",k);

}

——>15

解释：k=10*(x)<(y)?(x):(y)=10*(10)<(15)?(10):(15)

104.已知宏定义如下，若程序中的语句PR(D1,a)经预处理后展开为（）

#define PR printf
#define NL "\n"
#define D "%d"

#define D1 DNL

——>程序有错误

解释：D1 非法

105.C提供的预处理功能主要有三种，分别是（）、（）、（）

——>宏定义

——>文件包含

——>条件编译

106.阅读下面程序，写出运行结果（）

#define POWER(x) ((x)*(x))

int main(){

int i=1;

while(i<=4)

printf("%d",POWER(i++));

}

——>212

解释：

①i=1，POWER(1++)，((1)*(2))=2

②i=3，POWER(3++)，((3)*(4))=12

③i=5,不满足i<=4，跳出

107.定义语句char *abc="abc";那么功能完全相同的程序段是（）

——>char *abc;abc="abc";

108.设有定义语句int x[10]={1,2,3},*m=x;，则结果不能表示地址的表达式是（）

A)*m    B)m    C)x    D)&x[0]

——>A

解释：A选项，*m，表示m指向的地址的元素，表示1。其余选项均能表示地址x[0]。

109.定义int aa[8]则以下表达式中不能代表数组元素aa[1]的地址是（）

A)&aa[0]+1    B)&aa[1]    C)&aa[0]++    D)aa+1

——>C

解释：C选项不合法，如果是aa[0]++,表示的是aa[0]的元素

110.阅读下面程序，写出运行结果（）

int main(){

char a[]="morning",*p;

p=a;

printf("%c%c",*(p+3),*p+3);

}

——>np

解释：*(p+3)，指针p指向a[0],向后移动3位至n，输出n;*p+3,指向指针m， 字母顺序为mnop，移动3个位置，输出为p

111.阅读下面程序，写出运行结果（）

int main(){

int i=0;

char a[]="abcd",*p;

for(p=a;*p!='\0';p++)

    *p=*p+1;

for(p=a;*(p+i)!='\0';i++)

    printf("%c",*(p+i));

}

——>bcde

解释：第一个for循环，初始化p指向a[0]:a

①*p=a+1=b，*p指向p+1位置:b

②*p=b+1=c，*p指向p+1位置:c

③*p=c+1=d，*p指向p+1位置:""

④不满足循环，结束

第二个for循环，p指向a[0]:b，

①*p指向p+0位置，输出b

②*p指向p+1位置，输出c

③*p指向p+2位置，输出d

④*p指向p+3位置，输出e

112.阅读下面程序，写出运行结果（）

int main(){

int i=3,*p;

p=&i;*p=6;

printf("%d%d",i,*p);

}

——>66

解释：p指向i的值3，指针p的值被修改为6，即i的值被修改为6

113.阅读下面程序，写出运行结果（）

int main(){

int i=3,n=0,*p;

p=&n;

while(i<6){*p+=i++;}

printf("%d%d",*p,n);

}

——>1212

解释：p指向n的值0，while循环：

①i=3,i<6,*p=*p+3=3;

②i=4,i<6,*p=*p+4=3+4=7;

③i=5,i<6,*p=*p+5=7+5=12;

*p和n的值相同都为12

114.设有定义：int n1=0,n2,*p=&n2,*q=&n1,以下赋值语句中与n2=n1;语句等价的是（）

A)*p=*q;    B)p=q ;   C)*p=&n1;    D)p=*q;

——>A

解释：n2=n1;n1的地址被赋值给n2，因为*p=&n2,又因为*q=&n1;所以*p=*q，n2的值也有所改变；而其他选项都只影响指针

115.变量的指针，其含义是指该变量的（）

——>地址

116.阅读下面程序，写出运行结果（）

int main(){

char a[]={'1','2','3','4','5','6','7','8','9','0'},*p;

int i=8;

p=a+i;

printf("%s",p-3);}

——>6789

解释：p=a+i;p=a[0+8]=a[8]=9,输出p-3的字符串，p回退3个字符，至6，输出字符串至p,即6-9

117.运行后，i的结果是（）

int i; char *s="a\045+045\'b";

for(i=0;s++;i++);

——>8

解释：拆分char *s有这些元素：a、\04、5、+、04、5、\、b，执行7次成功，一次失败，i=8;

118.阅读下面程序，写出运行结果（）

int main(){

int a[][4]={1,3,5,7,9,11,13,15,17,19,21,23};

int (*p)[4],i=2,j=1;

p=a;

printf("%d",*(*(p+i)+j));

}

——>19

解释：int(*p)[4]，p为指向含4个元素的一维整形数组的指针；

          int *p[4]，p为4个指向整型数据的指针数组；

p=a[0]的地址，(*p)[4]{1,3,5,7}，输出首先看*(p+i)：p向后移动2位，至a[2]的地址；

*(p+i)+j：a[2][j]，即a[2][1];

*(*(p+i)+j)：a[2][1]的值，为19

119.若有定义int *p[4]，则标识符p（）

——>是一个指针数组名

120.若有语句int *point,a=4和point=&a，则下面均代表地址的一组选项是（）

——>&a,*&point,point

解释:a的地址，point指向的地址，point指向a的地址

121.若有说明:int *p,m=5,n;则以下正确的程序段是（）

A)p=&n;scanf("%d",&p);

B)p=&n;scanf("%d",*p);

C)scanf("%d",&n);*p=n;

D)p=&n;*p=m;

——>D

解释:选项A、B，正确为scanf("%d",p);选项C，p没有初始化不能赋值；选项D，p初始化为n，将p指向的地址赋值为m

122.有以下程序：

int main(){

char str[]="xyz",*ps=str;

while(*ps) ps++;

for(ps--;ps-str>=0;ps--)

puts(ps);

}输出结果为：

——>z

——>yz

——>xyz

解释：ps=str[0]=x;

while(*ps)①x，真，ps++,ps=str[1]=y;②y，真，ps++,ps=str[2]=z;③0，假，跳出

for循环①ps--，输出%s，输出z和0，换行②ps--，输出y-z，换行③ps--，输出x-z,换行

123.文件名为exam.exe，输出结果为（）

int main(int argc,char *argv[]){

int n,i=0;

while(argv[1][i]!='\0'){n=fun();i++;}

printf("%d",n*argc);}

int fun(){

static int s=0;

s+=1;

return s;}

输入以下命令 exam 123回车

——>6

解释：argv[0]="exam";argv[1]="123";argc=2

while(argv[1][0]!='\0'){n=fun();i++;}

①argv[1][0]=1,s=0,s=s+1=1;

②argv[1][1]=2,s=1,s=1+1=2;

③argv[1][2]=3,s=2,s=2+1=3;

n=3,输出n*argc=3*2=6

124.阅读下面程序，写出运行结果（）

int main(){

char a[]={9,8,7,6,5,4,3,2,1,0},*p=a+5;

printf("%d",*--p);

}

——>5

解释：p=a[6]=4;*--p=*(p-1)=a[5]=5

125.若有如下定义和语句，则输出结果为（）

char *sp="\t\b\\\0English\n";

printf("%d",strlen(sp));

——>3

解释：strlen()函数遇到\0结束，之前有\t、\b、\\三个元素

126.设char **s，则正确的表达式是（）

a) s=”computer”; 

b)*s=”computer”;

c.)**s=”computer”; 

d.)*s=’A’；

——>*s="computer";

解释：char**s 可以看作指向char* s的指针;

127.设有int a[]={10,11,12},*p=&a[0];则执行完*p++;*p+=1;后，a[0],a[1],a[2]的值依次是（）

——>10，12，12

解释：*p=a[0]=10;*p++;p指向a[1]；

*p+=1;*p=a[1]+1=12;

128.若有定义：char *x="abcdefgh";则以下选项中正确运用了strcpy函数的是（）

A)char y[10];strcpy(y,x[4]);

B)char y[10];strcpy(++y,&x[1]);

C)char y[10];strcpy(s=y+5,x);

D)char y[10];strcpy(s=y+1,x+1);

——>D

解释：strcpy()函数的两个参数都需要为指向字符地址的指针，A选项x[4]为字符，不满足条件

B选项，++y，y是常量地址，不能自增，错误

C选项，s是从y的第五个字符开始的字符串，x为10个字符，长度不符合

D选项，s是从y的第一个字符开始的字符串，x+1是从b开始的字符串，长度相同

129.若有定义：int w[3][5];则以下不能正确表示该数组元素的表达式是（）

A)*(*w+3)    B)*(w+1)[4]    C)*(*(w+1))    D)*(&w[0][0]+1)

——>B

解释：选项A，表示w[0][3]，w[0]+3列

选项B，正确的写法(*w+1)[4]，表示w[1][4]；

选项C，表示w[0][1];

选项D，表示w[0][1];

130.C语言中，数组名是一个不可改变的（），不能对它进行赋值运算。

数组在内存中占用一段连续的存储空间，它的首地址由（）表示。

——>常量

——>数组名

131.阅读下面程序，写出运行结果（）

int main(){

int a[]={2,3,4,5,6,7,8};

int s,i,*p;

s=1；

p=a+1;

for(i=1;i<4;i++)

    s*=*(p+i);

printf("%d",s);

}

——>120

解释：p=a[1]=3;

for循环①i=1,s=1*a[2]=1*4=4②i=2,s=4*a[3]=4*5=20③i=3,s=20*a[4]=20*6=120

132.以下程序的输出是（）

struct st{int x;int *y;}*p;

int dt[4]={10,20,30,40};

struct st aa[4]={50,&dt[0],60,&dt[0],60,&dt[0],60,&dt[0]};

int main(){

p=aa;

printf("%d\n",++p->x);

}

——>51

解释：p指向a[0],输出，p指向x，p自增1，50+1，51；如果是p++->的话，p指向50，下一次执行时p指向60

133.以下程序的输出是（）

int main(){

struct abcd{int m;int n;}cm[2]={1,2,3,7};

printf("%d\n",cm[0].n/cm[0].m*cm[1].m);

}

——>6

解释：cm[0].n=2,cm[0].m=1;cm[1].m=3;输出2/1*3=6

134.若有下面的说明和定义，则sizeof(struct word)的值是（）

struct word{

int a;char b; float c;

union uu{float u;int v;}ua;

}myaa;

——>13

解释：int 4字节，char 1个字节，float 4个字节，union中最大的字节数为4；

4+(1+3)+4+4=16，实际为16，但是题目为13.

134.若有下面的说明和定义，则sizeof(a)的值是()，而sizeof(b)的值是（）

struct tu{int m;char n; int y;}a;

struct    {float p;char q; struct tu r;}b;

——>12

——>20

解释：tu a的字节数为:4+1+4=9，但是在C语言中有空间对齐的说法，在32位系统中以4个字节为一行，因此4+(1+3)+4=12；

b的字节数为4+(1+3)+12=20；

135.设有下面结构类型说明和变量定义，则变量a在内存中所占字节数是（）,如果将该结构改成共同体，结果为（）

struct stud{char num[6]; int s[4]; double ave;}a;

——>32

——>16

解释：结构体a的字节数为:4+(2+2)+4*4+8=32，double所占字节为4或8；

共同体a的字节数为:int[4]=4*4=16;

136.以下程序的输出结果是（）

struct HAR{int x,y;struct HAR *p;}h[2];

int main(){

h[0].x=1;h[0].y=2;

h[1].x=3;h[1].y=4;

h[0].p=&h[1].x;

h[1].p=&h[0].x;

printf("%d%d\n",(h[0].p)->x,(h[1]).p->y);

}

——>32

解释：h[0].p=&h[1].x=3;指向h[1]，h[1].p=&h[0].x=1;指向h[0]

输出(h[0].p)->x，即h[1].x=3;输出(h[1].p)->y，即h[0].y=2

137.若有定义语句：char *name[]={"JAME","XML","C++"};则name[2]的值是（）

——>一个地址

138.以下程序的输出结果是（）

int main(){

int *a,*b,*c;

a=(int *)malloc(sizeof(int));

*a=3;*b=4;*c=5;

printf("%d,%d,%d",*a,*b,*c);

}

——>555

解释：指针abc共享一个空间，*a为3，*b为4，*c为5，*a/*b/*c都为5

140.设有以下语句，则z的二进制值是（）

char x=3,y=6,z;

z=x^y<<2;

——>00011011

解释：x的二进制为:11,y的二进制为:110;x^y=100;100<<2=10011，左移两位并填上1

141.以下程序的输出结果是（）

int x=20;printf("%d\n",~x);

——>-21

解释：取反的十进制数等于增1在加上符号

142.以下程序的输出结果是（）

int x=1,y=2;x=x^y;y=y^x;x=x^y;

printf("x=%d,y=%d\n",x,y);

——>x=2,y=1

解释：x的二进制为:1,y的二进制为:10;

x=1^2=11(2);y=2^11=01(2);x=01^1=10(2)

143.若a=1,b=2;则a|b的值是（）

——>3

解释：a的二进制为:1,b的二进制为:10; a|b=1|10=11(2)=3

144.在C程序中，可把整型数以二进制形式存放在文件中的函数是（）

——>fwrite函数

145.若fp是指向某文件的指针，且已经读到此文件末尾，则库函数feof(of)的返回值是（）

——>非零值

解释：feof()函数：其原型在stdio.h中，其功能是检测流上的文件结束符，如果文件结束，则返回非0值，否则返回0，文件结束符只能被clearerr()清除。

146.在C语言文件中，按照不同的分类标准有不同的分类形式，其中，按照文件编码方式可将文件分成（）和（）

——>二进制文件和文本文件

147.使用fopen("abc","r")打开文件时，若abc文件不存在，则返回（）

——>空指针

148.使用fopen("abc","w")打开文件时，若abc文件已存在，则（）

——>将原文件覆盖

解释：文件不存在时，直接创建一个该名字的文件

149.在C语言中，文件指针设置函数是()，文件指针检测函数是（）

——>fseek(),ftell()

150.在C语言中，文件可用（）方式存取，也可用（）方式存取

——>字节，流

151.在C语言中，文件的存取是以（）为单位的，这种文件被称为（）文件

——>顺序，随机

152.rewind()函数的作用（）

——>指针定位到文件开头

153.文件中存放“hello word”时以下程序的输出结果是（）

#include

int main(){

FILE *fp;char str[10];

fp=fopen("a1.txt","r");

fgets(str,5,fp);

printf("%s",str);

fclose(fp);

}

——>hell

解释：fgets读取n-1个字节，即前四个hell

154.以下程序的输出结果是（）

#include

int main(){

FILE *fp;int a[8]={1,2,3,4,5,6,7,8};int i;

fp=fopen("d.dat","wb+");

fwrite(a,sizeof(int),8,fp);

fseek(fp,sizeof(int)*4,SEEK_SET);

fread(a,sizeof(int),4,fp);

fclose(fp);

for(i=0;i<8;i++)

    printf("%c",a[i]);

}

——>5,6,7,8,5,6,7,8

解释：fwrite()，在文件中写入8个数字；

fseek()，SEEK_SET文件头，将指针偏移4个int字节的长度后的位置，即以5开始的数组；

fread()，读入指针4个字节，前四个字节1234被替换为5678，for循环输出8个数字

155.已知int x=25;x^=25;x的值是（）

——>0

156.以下程序段的输出结果是（）

enum t{a,b=4,c,d=c+10}

printf("%d %d %d %d",a,b,c,d);

——>0 4 5 15 

解释：枚举下标从0开始，a=0,b被赋值为4，b=4,c=b+1=5,d=5+10=15

157.typedef数据类型命名步骤1）（）2）（）3）（）

——>按定义变量的方法，写出定义体

——>将变量名换成别名

——>在定义体前面加上typedef