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<b的值为()

——>1

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

②0<b,真,返回1

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<stdio.h>

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 <stdio.h>

#include <string.h>

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<stdio.h>

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<stdio.h>

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


发布了48 篇原创文章 · 获赞 48 · 访问量 6万+
展开阅读全文

没有更多推荐了,返回首页

©️2019 CSDN 皮肤主题: 大白 设计师: CSDN官方博客

分享到微信朋友圈

×

扫一扫,手机浏览