江苏省计算机二级c++考试试题集Word格式文档下载.docx

江苏省计算机二级c++考试试题集Word格式文档下载.docx

《江苏省计算机二级c++考试试题集Word格式文档下载.docx》由会员分享，可在线阅读，更多相关《江苏省计算机二级c++考试试题集Word格式文档下载.docx（61页珍藏版）》请在冰豆网上搜索。

A．派生类的对象可以赋值给基类的对象

B．基类的对象可以赋值给派生类的对象

C．派生类的对象可以初始化其基类的引用

D．可以将派生类对象的地址赋值给其基类的指针变量

29.下列关于变量的叙述中不正确的是（29）。

A．C++语言中将变量分为auto、static、extern和register四种存储类型

B．自动变量和外部变量的作用域为整个程序文件

C．函数内定义的静态变量的作用域为定义它的函数体

D．外部静态变量的作用域为定义它的文件内

30.设有说明语句：

chara[]=”string!

”,*p=a;

以下选项中正确的是（30）。

A．sizeof（a）的值与strlen（a）的值相等B．strlen（a）的值与strlen（p）的值相等

C．sizeof（a）的值与sizeof（p）的值相等D．sizeof（a）的值与sizeof（*p）的值相等

二、填空题（请将答案填写在答题纸的相应答题号内）

●基本概念题（共5分）

1.当一个类的非静态成员函数被调用时，该成员函数的

（1）指向调用它的对象。

2.C++语言中的友元函数提供了在类外访问类中私有成员和保护成员的功能，但破坏了类的

（2）。

3.使用成员函数对双目运算符进行重载时，其左操作数是（3）。

4.设有宏定义和变量说明：

#defineT（x,y）x+y

inta=T（3,4）*T（3,5）

则变量a的初值为（4）。

5.设有说明语句：

inta[][4]={{1,2},{2,3,4,5}},*p=（int*）a;

则*（p+5）的值为（5）。

●阅读程序题（共13分）

6.【程序】

（3分）

#include<

iostream.h>

string.h>

intisvowel（charc）

{return（c==’a’||c==’e’||c==’i’||c==’o’||c==’u’）;

}

voidpluralize（char*s）

{intlen=strlen（s）;

char*p=s+len-1;

char*q=s+len-2;

if（*p==’h’&

（*q==’c’||*q==’s’））strcat（p,“es”）;

elseif（*p==’s’）strcat（p,“es”）;

elseif（*p==’y’）

if（isvowel（*q））strcat（p,“s”）;

elsestrcpy（p,“ies”）;

elseif（*p==’z’）

if（isvowel（*q））strcat（p,“zes”）;

elsestrcat（p,“es”）;

elsestrcat（p,“s”）;

}

voidmain（void）

{

charword[6][20]={“wish”,“bus”,“toy”,“navy”,“quiz”,“computer”};

for（inti=0;

i<

6;

i++）{

pluralize（word[i]）;

cout<

word[i]<

’\t’;

if（（i+1）%2==0）cout<

’\n’;

程序输出的第一行是（6），第二行是（7），第三行是（8）。

7.【程序】

voidf（intj）

{if（!

j）{cout<

j;

return;

if（j%2）{f（j/10）;

j%10;

else{cout<

f（j/10）;

{f（0）;

’\n’;

f（1357）;

f（2468）;

程序输出的第一行是（9），第二行是（10），第三行是（11）。

8.【程序】

intx=2,y=x+30;

classA{

inty;

staticintx;

public:

operatorint（）

{returnx+y;

Aoperator++（int）

{returnA（x++,y++）;

A（intx=2,inty=3）

{A:

:

x=:

x+x;

A:

y=:

y+y;

voidprint（）

{cout<

”x=”<

x<

”,\t”<

”y=”<

y<

endl;

};

intA:

x=23;

{Aa（54,3）,b（65）,c;

a.print（）;

inti=a+b;

”i=”<

i<

endl;

c++;

c.print（）;

程序输出的第一行是（12），第二行是（13），第三行是（14）。

9.【程序】

（2分）

char*f（char*s,charch）

{char*p=s,*q=s;

while（*q=*p++）if（*q!

=ch）q++;

returns;

{chars1[]=”HelloHowareyou”,s2[]=”110010111”;

f（s1,’e’）<

f（s2,‘0’）<

程序输出的第一行是（15），第二行是（16）。

10.【程序】

intx,y;

A（inti,intj）{x=i;

y=j;

operator++（int）

++x<

‘’<

++y<

”重载1”<

friendAopertor++（A）;

Aopertor++（Aop）

{cout<

++op.x<

++op.y<

”重载2”<

voidmain（void）

{Aa（1,2）;

++a;

a++;

程序输出的第一行是（17），第二行是（18）。

●完善程序题（共12分）

11.下面程序的功能是：

先输入一行字符串，并从输入的字符串中找到最小的字符（其ASCII值最小），用min保存该字符。

然后将该字符前的所有字符顺序往后移动一个字符位置。

最后，将保存的字符放在该字符串的第0个位置上。

例如，设输入的字符串为

“bcdfae”，其中字母a为最小字符，经移动处理后，输出的字符串为“abcdfe”。

【程序】

（4分）

voidfun（char*str）

{charmin,*q,*p;

（19）;

min=*p++;

while（*p!

=’\0’）{

if（（20））{min=*p;

q=p;

p++;

p=q;

while（（21））{*p=*（p-1）;

（22）;

*p=min;

{charstr[80];

cin.getline（str,80）;

fun（str）;

str<

12.用程序模拟两个大整数（为简化程序，设整数为正数）的加法运算。

假定一个整数最多N位，用一个一维数组存放其各位数字。

在数组下标为0的元素中存放该整数的个位数字，在下标为1的元素中存放该整数的十位数字，依此类推。

例如，大整数a的值为88099005798957，大整数b的值为776988213577，则两个整数相加的结果为88875994012534。

以下是程序输出的结果：

Integera:

88099005798957

Integerb:

776988213577

Sum:

88875994012534

#defineN20//整数的位数

voidadd（intsum[],inta[],intb[]）;

//sum=a+b

voidwrt（（23））;

{inta[N]={7,5,9,8,9,7,5,0,0,9,9,0,8,8};

intb[N]={7,7,5,3,1,2,8,8,9,6,7,7};

intsum[N];

add（sum,a,b）;

wrt（“Intrgera:

”,a）;

wrt（“Intrgerb:

”,b）;

wrt（“Sum:

”,sum）;

voidadd（intsum[],inta[],intb[]）

{intcarry=0,i;

//carry表示进位

for（i=0;

N;

++i）{

sum[i]=（24）;

if（sum[i]<

10）carry=0;

else{carry=sum[i]/10;

sum[i]=（25）;

voidwrt（constchar*s,inta[]）

{inti;

cout<

s;

for（（26）;

i>

0&

a[i]==0;

--i）//输出前导空格

（‘‘）;

//输出一个空格

for（;

=0;

--i）cout<

a[i];

’\n’;

13.下面程序先建立一条单向链表，其中每个结点包含产品名称和产品类别。

然后对链表中的结点按产品类别进行分类，将同类别产品的结点放在一起。

具体实现过程为：

依次从已建立的链表上取下一个结点，根据该结点的产品类别值插入到新的链表中。

插入过程为：

若新链表上已有该产品类别的结点，则将结点插入到同类别结点的最后一个结点的后面；

否则，将该结点插入到新链表的最后一个结点的后面。

最后，输出分类后链表上各个结点的信息。

structnode{

charproduct[20];

//产品名称

charcategory[10];

//产品类别

node*next;

node*create（void）//创建链表

{nodetemp,*p2=&

temp;

charproduct[20],category[10];

while

（1）{

”输入产品名称和类别，当输入产品名称为end时表示结束：

”;

cin>

product>

category;

if（strcmp（product,“end”）==0）break;

p2->

next=newnode;

p2=p2->

next;

strcpy（p2->

product,product）;

category,category）;

（27）;

returntemp.next;

voidprint（node*h）//输出链表h

{while（h）{

h->

product<

’\t’<

category<

h=h->

voiddeletechain（node*h）//删除链表h

{node*p;

while（（28））{h=h->

deletep;

node*insertascategory（node*h,node*p）//按类别插入结点

{node*p2=0,*p1=h;

if（h==0）{p->

next=0;

returnp;

while（p1&

strcmp（p1->

category,p->

category））{

p2=p1;

p1=p1->

}//找同类结点

category）==0）{

}//定位在同类结点后

p->

next=p1;

（29）;

//插入在p1、p2结点之间

returnh;

node*classify（node*h）//按类别分类

{node*h2=0,*p;

while（h）{

p=h;

（30）;

h2=insertascategory（h2,p）;

returnh2;

{node*h;

h=create（）;

print（h）;

h=classify（h）;

deletechain（h）;

2007年（春）笔试试卷

21.设有变量说明：

“shortinta=0,b=0;

”，则表达式sizeof（‘a’+’b’）的值为（21）。

A．1B．2C．4D．8

22.下列关于while与do…while循环语句的叙述中正确的是（22）。

A．do…while的循环体至少执行一次

B．while的循环体至少执行一次

C．do…while的循环体不能是复合语句

D．do…while允许从循环体外跳转到循环体内

23.设有函数原型说明：

voidtest（inta,intb=7,char*c=”#”）;

下面的函数调用中存在语法错误的是（23）。

A．test（3）B．test（3,8.2）C．test（6,”*”）D．test（0,0,”*”）

24.执行以下程序时，输入一行字符串为

Thankyouverymuch!

程序的输出结果为（24）。

#include<

voidmain（void）

{

charline[100];

line;

line<

A．TB．Thank

C．Thankyouverymuch!

D．Thankyou

25.下列关于运算符重载的叙述中正确的是（25）。

A．运算符重载可以改变操作数的个数

B．运算符重载可以改变运算符的优先级

C．运算符重载可以改变运算符的结合性

D．运算符重载不能改变操作数的个数，也不能改变运算符的优先级和结合性

26.定义以下的类：

classX{

inta;

X（intx=0）{a=x;

classY:

publicX{

intb;

Y（intx=0,inty=0）:

X（y）{b=x;

在以下选项的说明语句中，存在语法错误的是（26）。

A．X*pa=newY（1,2）;

B．Xa1=Y（1,3）;

C．Xb2（2,3）;

Y&

a2=b2;

D．Yb3（10）;

Xa3（b3）;

27.设有以下语句：

inta=5;

intarr[a];

//第1行

constintb=5;

intx[b];

//第2行

intc=5;

int*p=newint[c];

//第3行

constintd=5;

int*p1=newint[d];

//第4行

其中存在语法错误的是（27）。

A．第1行B．第2行C．第3行D．第4行

28.设有说明语句：

floata[3][3]={1,2,3,4,5},*b[3]={0},（*c）[3]=a,**d=0;

以下选项中语法正确的语句是（28）。

A．a[0]=b[0];

B．b[0]=c[0];

C．c[0]=d[0];

D．d[0]=a[0][0];

29.下列关于虚函数的描述中正确的是（29）。

A．虚函数可以是一个static类型的成员函数

B．虚函数可以是一个非成员函数

C．虚函数可以实现静态多态性

D．基类中采用virtual说明一个虚函数后，派生类中定义相同原型的虚函数时，可不必加virtual说明

30.设变量a、b是整型变量，下列switch语句中语法正确的是（30）。

A．switch（a）{B．switch（a+b）{

casea:

break;

case1:

b=a++;

caseb:

b++;

a=++b;

}}

C．switch（a*a）{D．switch（a/10+b）{

case10,12:

++a;

case3:

b=a/10;

break;

case14,16:

++b;

default:

a+=b;

}}

二、填空题

6.对于switch（e），表达式e只能是整型、

（1）或枚举型表达式。

7.面向对象程序设计的三大特性是封装性、继承性和

（2）。

8.执行以下语句后，a的值为（3）。

inta=0,m=3,n=10;

a=（m++,m+n）;

9.在C++中，标识符是以字母或（4）开头的，由字母、数字和（4）组成的字符序列。

10.在C++中，类的每一个非静态成员函数都有一个（5）指针，该指针指向正在调用成员函数的对象。

intfun（intx,inty）

x=x+y;

y=x+y;

”x=”<

x<

”,y=”<

y<

returnx+y;

intx=5,y=8,z=fun（x,y）;

”x=”<

”z=”<

z<

程序输出的第二行是（6），第三行是（7）。

intf（intm,int&

n）

{staticinta=1;

intc=2;

m+=++a;

n+=++c;

returnm+n;

{inta=1,b=2;

f（a,b）<

a<

’\t’<

b<

f（f（a,b）,b）<

程序输出的第一行是（8），第二行是（9），第三行是（10）。

voidfindmax（int*a,intn,inti,int*pk）

{if（i<

n）{

if（a[i]>

a[*pk]）*pk=i;

findmax（a,n,i+1,pk）;

{inta[10]={34,32,23,12,67,54,44,60,33,24},index=0;

findmax（a,10,0,&

index）;

a[index]<

”Its’indexis:

”<

index<

程序输出的第一行是（11），第二行是（12）。

inta=100;