计算机软考软件设计师考前练习试题及答案Word下载.docx

计算机软考软件设计师考前练习试题及答案Word下载.docx

《计算机软考软件设计师考前练习试题及答案Word下载.docx》由会员分享，可在线阅读，更多相关《计算机软考软件设计师考前练习试题及答案Word下载.docx（12页珍藏版）》请在冰豆网上搜索。

*x=*y;

*y=*p;

　　}B.funb（intx，inty）

　　{intt;

　　t=x;

x=y;

y=t;

　　}

　　C.func（int*x，int*y）

　　{intp;

　　p=*x;

*y=p;

　　D.fund（int*x，int*y）

　　{

　　*x=*x+*y;

*y=*x-*y;

*x=*x-*y;

（122）A,B。

　　解析：

设计实现交换两个变量值的函数。

希望函数调用能改变调用环境中的变量，方法之一是让函数设置指针类型的形参，实参传送给形参的是希望交换值的两个变量的指针。

函数的两个形参得到这两个变量的指针后，函数就能通过形参间接引用要交换值的变量，或引用它们的值，或改变它们的值。

从而实现从函数传回信息存于调用环境的变量中。

以上所述是设计交换变量值函数的一般原则，具体编写函数时还需注意对上述原则的准确应用。

　　对于函数funa，该函数的定义满足设置指针形参，并通过指针形参间接引用环境变量的要求。

但是在函数体中定义了指针变量p，并在p宋明确设定它所指向的变量下，代码*p=*x企图将值存入它所指的变量中，这是初学者经常出现的一种严重的错误。

该函数因有错，不能实现交换变量值的功能。

　　对于函数funb，该函数不定义指针形参，函数体也没有可用的指针间接引用调用环境中的变量，所以该函数也不能实现交换变量值的功能。

　　对于函数func，该函数准确定义了指针形参，函数体也准确通过指针形参间接引用环境中的变量，并准确定义了自己的局部变量。

该函数能实现交换变量值的功能。

　　对于函数fund，该函数也准确定义指针形参和函数体通过形参间接引用环境变量。

特别要指出的是，该函数是利用*x和*y的;

日值与新值之间的关系实现问题要求的。

其中第一个赋值使。

x存有原来未交换之前的*x与*y之和;

第二个赋值从这个和中减去原来的*y，并将差赋给*y，使*y的值是交换之前的*x的值;

第三个赋值再次从和中减去新的*y，即减去交换之前的*x，这个差就是交换之前的*y，并将差赋给*x。

经以上三个赋值，实现两变量之间的值交换。

所以不能准确执行交换变量值的函数是funa和funb，即准确选择是A,B。

　　104.设有定义“chara[10]={"

abcd"

}，*p=a;

"

，则*（p+4）的值是（123）

　　（123）A."

abCd"

　　B.’d’

　　C.’\0’

　　D.不能确定

（123）C。

若有chara[10]="

，*p=a，则指针变量p指向a[0]。

在表达式*（p+4）中，p+4指向a[4]，*（p+4）就是a[4]。

因为用字符"

给字符数组a赋初值，a[4]的值是字符串结束标记符’\0’。

所以解答是C。

　　105.设有代码"

int（*ptr）[10];

”，其中的ptr是（124）

　　（124）A.10个指向整型变量的指针

　　B.指向10个整型变量的函数指针

　　C.一个指向具有10个元素的一维数组的指针

　　D.具有10个指针元素的一维数组

（124）C。

代码“int（*ptr）[10];

”的分析过程是，因圆括号，括号内的ptr先与字符*结合，字符*修饰标识符ptr是一种指针;

接着与后面的一对方括号结合，表示是这样的一种指针，是指向一维数组的;

再有方括号中的10，说明这种数组有10个元素。

至此，ptr是指向含10个元素的一维数组的指针。

最后，是最前面的int，表示数组元素是int类型的。

所以，ptr是一个指向具有10个int型元素的一维数组的指针。

另外，要是A，10个指向整型变量的指针，就是一个指针数组，上述代码应写成“int*ptr[10];

”，即ptr是一个有10个指向整型变量的数组。

要是B，返回值是指向10个整型变量的函数的指针，上述代码应写成“int（*（*ptr）（））[10];

”，即ptr是指针，指向一种函数，函数的返回值又是一种指针，指向10个元素的数组，数组的元素是整型的。

下面的代码是这样的函数指针和函数的例子：

　　#include

　　inta[][10]={{1，2，3，4，5，6，7，8，9，0}，{0，1，2，3，4，5，6，7，8，9}};

　　int（*（*ptr）（int））[10];

　　int（*f（intn））[10]

　　{returna+n;

　　voidmain（）

　　{int（*p）[10]，*q;

　　ptr=f;

/*让ptr指向函数f*/

　　P=（*ptr）（0）;

　　q=*p;

　　printf（"

%d"

*p）;

　　P=（*ptr）（l）;

*q）;

　　在上述代码中，函数有一个int型的形参。

要是D，其意义与A相同，上述代码应写成“int*ptr[10];

”，即ptr是一个有10个元素的数组，数组元素是指向整型变量的指针。

　　106.若有以下定义，则数值为4的表达式是（125）

　　intw[3][4]={{0，1}，{2，4}，{5，8}}，（*p）[4]=W;

　　（125）A.*w[1]+l

　　B.p++，*（p+1）

　　C.w[2][2]

　　D.p[1][1]

（125）D。

二维数组定义有多种赋初值的办法，问题给出的代码是按行给数组的部分元素赋初值。

它们分别是w[0][0]=0.w[0][1]=1、w[1][1]=2.w[1][1]=4,w[2][0]=5,w[2][1]=8。

根据约定，未指定初值的元素自动置全0值。

指针变量p是一个指向具有四个int型元素的一维数组的指针，定义时的初值使它指向数组W的第一行。

A的代码，*w[1]+1中的W[l]是指向w[l][0]的指针，*w[1]就是w[1][0]，其值是2，*w[1]+l的值是3。

B的代码是逗号表达式，“p++，*（p+1）”先使p指向数组w的第二行，*（p+l）中的p+l是指向数组w的第三行，*（p+1）是指针值，指向数组w的第三行的第一个元素，即&

w[2][0].C的代码w[2][2]引用数组W第三行的第三列元素，其值是0。

D的代码p[1][l]引用数组W第二行的第二列元素w[1][1]，其值是4。

所以解答是D。

　　107.若有下面的程序片段，则对数组元素的错误的引用是（126）

　　inta[12]={0},*p[3],**pp，i;

　　for（i=0;

i<

3;

i++）p[i]=&

a[i+4];

　　pp=P;

　　126）A.pp[0][1]

　　B.a[10]

　　C.p[3][l]

　　D.*（*（p+2）+2）

（126）C。

上述代码定义变量a是有12个整型元素的数组，它的初值全是0。

p是有三个元素的指针数组，每个指针能指向整型变量。

哪是指针的指针，它能指向一个指向整型变量的指针，i是一个整型变量。

执行代码for（i=0;

i++）P[i]=&

a[i+4]使指针数组p的元素p[0]指向a[4]，p[l]指向a[5]，p[2]指向a[6]。

代码pp=p使指针变量pp指向p[0]。

A代码pp[0][l]用指针表达可等价地写成*（*pp+l）。

其中*pp就是p[0]，p[0]的值是&

a[4]，*pp+1的值是&

a[4]+1=&

a[5]，*（*pp+1）就是a[5]。

B代码a[l0]当然是引用数组a的元素。

C代码p[3][1]数组p只有三个元素，没有p[3]，所以是错误的。

D代码*（*（p+2）+2）中的（p+2）是&

p[2]，*（p+2）是p[2]，其值是&

a[6],*（p+2）+2的值是&

a[8]，*（*（p+2）+2）引用的是a[8]。

　　108.若有如下定义和语句，则输出结果是（127）

　　int**pp，*p，a=10，b=20;

　　PP=&

p;

P=&

a;

b;

printf（"

%d%d"

，*p，**PP）;

　　（127）A.10，20

　　B.10，10

　　C.20，10

　　D.20，20

（127）D。

上述代码定义变量pp是指针的指针，它能指向一个指向整型变量的指针。

定义变量p是指针，它能指向一个整型变量。

a是一个整型变量，它有初值10。

b也是一个整型变量，它有初值20。

代码pp=&

p使pp指向p，p=&

a使p指向a，p=&

b又使p指向b，不再指向a。

所以。

p是引用b，其值为20。

**pp是通过pp间接引用p，再通过p间接引用b，所以也是20。

　　109.若有以下定义和语句，则对w数组元素的非法引用是（128）

　　intw[2][3]，（*pw）[3];

pw=w;

　　（128）A.*（w[0]+2）

　　B.*pw[2]

　　C.pw[0][0]

　　D.*（pw[l]+2）

（128）B。

上述代码定义2行3列的二维数组w，定义能指向有3个整型元素一维数组的指针pw，并让pw指向数组w的第一行。

A代码*（w[0]+2）中的w[0]是&

w[0][0]，w[0]+2是&

w[0][2]，所以*（w[0]+2）就是w[0][2]。

B代码*pw[2]中的pw[2]是&

w[2][0]，该数组w只有2行，没有w[2][0]，所以代码*pw[2]是对数组W元素的非法引用。

C代码pw[0][0]就是w[0][0]。

D代码*（pw[l]+2）中的pw[1]就是*（pw+l），即&

w[l][0]，pw[l]+2就是&

w[l][2]，所以*（pw[1]+2）就是w[1][2]。

所以解答是B。

　　110.若有下列说明，则数值为4的表达式是（129）

　　inta[12]={l，2，3，4，5，6，7，8，9，10，11，12};

　　charc=‘a’，d，g;

　　（129）A.a[g-c]

　　B.a[4]

　　C.a[’d’-’c’]

　　D.a[’d’-c]

（129）D。

数组元素的下标自0开始顺序编号，值为4的元素是a[3]。

所以只有下标表达式的值为3的才是准确的。

下标表达式g-C中的的变量g和c的值是还未被设定的，其值不确定。

a[4]的值为5，下标为4是不对的。

’d’-’c’的值为1，a[l]的值是2，所以也是不对的。

变量c的值为’a’，’d’-c=3，所以准确解答是D。

　　111.设有定义：

chars[12]={"

string"

};

则printf（"

，strlen（s））;

的输出是（130）

　　（130）A.6

　　B.7

　　C.11

　　D.12

（130）A。

在C语言中，字符串是指在有效字符之后有字符率结束标记符的字符列，并约定字符串的长度是指字符率中有效字符个数，不包括字符串的结束标记符。

存放于字符数组s中的字符串是“string”，该字符串的长度为6，所以输出该字符串的长度应是6。

准确的解答是A。

A错误的原因是整数数组不能够用字符串对其初始化。

B错误的原因是，数组初始化时，初始化指定的值的个数多于数组的元素个数。

C错误的原因是，能用字符串初始化的只;

有字符指针变量，或字符数组。

字符率不能对其它类型的变量初始化，包括字符变量。

D是准确的，因为字符数组能够用小整数（作为字符的ASCII代码值）对其元素初始化。

　　114.语句"

strlen（"

atsol2\1\\"

））;

的输出结果是（133）

　　（133）A.11

　　B.10

　　C.9

　　D.8

（133）C。

字符串中的字符能够是一般的普通字符，也能够是由反斜杠字符开头的转义字符。

在字符串"

abso12\11\\"

中，有三个转义字符，它们是、\1、\\，所以该字符串的有效字符个数是9。

所以准确的回答是C。

　　115.函数调用“strcat（strcpy（strl，str2），str3）”的功能是（134）

　　（134）A.将字符串strl复制到字符串str2中后再连接到字符串str3之后

　　B.将字符串strl连接到字符串str2中后再复制到字符率str3之后

　　C.将字符串str2复制到字符串strl中后再将字符串str3连接到字符串strl之后

　　D.将字符串str2连接到字符率strl之后再将字符串strl复制到字符串str3中

（134）C。

函数调用strcat（s1，s2）是将s2字符串复制连接到s1字符串之后，使s1字符串变得更长。

函数调用strcpy（s1，s2）是将s2字符串复制到s1，使s1字符串的内容与s2字符串的内容相同。

函数调用strcat（strcpy（strl，str2），str3）是先执行strcpy（strl，str2），然后再执行strcat（strl,str3），所以其功能是将字符串str2复制到字符串strl中，然后再将字符串str3复制连接到字符串strl之后。

准确的选择是C。

　　116.设有如下定义，则准确的叙述为（135）

　　charx[]={"

abcdefg"

　　chary[]={’a’，’b’，’c’，’d’，’e’，’f’，’g’};

　　（135）A.数组x和数组y等价

　　B.