笔试B卷09103C++电类Ⅱ.docx

笔试B卷09103C++电类Ⅱ.docx

《笔试B卷09103C++电类Ⅱ.docx》由会员分享，可在线阅读，更多相关《笔试B卷09103C++电类Ⅱ.docx（18页珍藏版）》请在冰豆网上搜索。

笔试B卷09103C++电类Ⅱ

东南大学考试卷（B卷）

课程名称

程序设计及算法语言（电类）Ⅱ

考试学期

09-10-3

得分

适用专业

电类

考试形式

闭卷

考试时间长度

120分钟

（）

题目

一

二

三

四

总分

得分

批阅人

自觉遵守考场纪律如考试作弊此答卷无效

一、选择题（每题1分，共10分）

1．设有变量定义：

intaval=20;int*ap;double*dp;下面赋值正确的是____。

A.ap=aval;B.*dp=*ap;C.dp=ap;D.*ap=&aval;

2．在数组intarray[4][4]={{32,1,8},{9,28,13,7},{11,39},{85,76}}中，array[2][2]的值是

。

A.0B.28C.39D.13

3.假设对4个元素A、B、C、D、E进行压栈或出栈的操作，压栈的先后顺序是ABCD，则出栈的先后顺序不可能是。

A.ABCDB.DCBAC.BCADD.DCAB

4.通过new运算符动态创建的对象的存放在中。

A.代码区B.栈区C.自由存储区D.全局数据区

5.下列关于纯虚函数的判断中，是错误的。

A.含有纯虚函数的类是抽象类

B.纯虚函数定义的函数体为空

C.含有纯虚函数的基类不能实例化

D.由含有纯虚函数的基类派生出的派生类必须重新定义纯虚函数的函数体才能使用

6.假设已有两个独立的类classA和classB，新的类classC继承了classA，聚合了一个classB的对象b。

那么classC的对象的构造顺序是。

A.首先调用基类构造函数A（），其次调用数据成员对象b的构造函数B（），最后执行派生类的构造函数C（）的函数体。

B.首先调用数据成员对象b的构造函数B（），其次调用基类构造函数A（），最后执行派生类的构造函数C（）的函数体。

C.首先执行派生类的构造函数C（）的函数体，其次调用数据成员对象b的构造函数B（），最后调用基类构造函数A（）。

D.首先执行派生类的构造函数C（）的函数体，其次调用基类构造函数A（），最后调用数据成员对象b的构造函数B（）。

7.链表不具有的特点是。

A.元素的存储地址可以不连续

B.存储空间根据需要动态开辟，不会溢出

C.可以直接随机访问元素

D.插入和删除元素的时间开销与位置无关

8.编制派生类时分下列四步顺序进行，下面的描述哪一步有错误？

（A）吸收基类的成员，除构造函数与析构函数外，全部吸收为派生类的成员。

（B）改造基类成员，如果派生类声明了一个和某个基类成员同名的新成员，当基类的成员函数是虚函数，且派生类的成员函数与基类的成员函数声明一致，构成同名覆盖。

如果仅是同名或着基类的成员函数不是虚函数，则构成同名隐藏。

（C）发展新成员，新成员必须与基类成员不同名，派生类新成员的加入使得派生类在功能上有所发展。

（D）重写构造函数与析构函数，因为派生类不继承这两种函数。

基类的构造函数与析构函数完全不可利用。

9.实现多态的派生类函数不一定要。

A．与基类虚函数同名B．用virtual修饰

C．与基类虚函数同参数表D．与基类虚函数同返回类型

10.在get、getline、read和>>四个标准输入流成员函数中有个可以读取字符串。

A.1B.2C.3D.4

二、填空题（每空1分，共20分）

1.顺序表是以数组为基础的，当使用时数组元素不够用时是不能增加的，所以在定义顺序表时数组必须大开。

2.的线性表才可以进行对半查找。

3.有序数组intB[17]中存放17个元素，用对半查找法找到B[6]元素，则进行比较的数组下标值依次是，，，6。

4.类的继承方式有：

、和。

5.以下程序中Sort（）函数是顺序表的成员函数。

templatevoidOrderedlist:

:

Sort（）{

Ttemp;

inti,j;

for（i=1;i<=last;i++）{

temp=slist[i];j=i;

while（j>0&&temp

slist[j]=slist[j-1];j--;//查找与移动同时做

}

slist[j]=temp;

}

}

该成员函数用到的是排序。

若未排序前的数据为：

553498217643

for循环执行完第一次后的数据顺序为：

6.运算符重载时，其函数名由构成。

成员函数重载双目运算符时，左操作数是，右操作数是。

7.对含有动态分配的数据成员的类对象应该采用复制，动态分配的资源通常要求在中释放，

8.全局标准流对象有、、和。

9.通过表达式可以判断文件流fd是否正确打开。

三、阅读程序,根据要求填空：

（共40分）

1.写出下面程序的输出结果（每空1~2分，本题8分）

#include

usingnamespacestd;

classCSample{

intn;

staticintk;

public:

CSample（inti）

{

cout<<"constructoriscalled\n";

n=i;k++;

}

~CSample（）

{

cout<<"destructoriscalled\n";

}

voiddisp（）

{

cout<<"n="<

}

};

intCSample:

:

k=0;

intmain（）

{

CSamplea（10）,b（20）;

a.disp（）;

b.disp（）;

return0;

}

输出结果：

（1分）

（1分）

（2分）

（2分）

（1分）

（1分）

2.写出下面程序的输出结果（每空2分，共4分）

#include

usingnamespacestd;

intMAX（int*arr,intn）

{

inti,max=arr[0];

for（i=0;i

if（arr[i]>max）

max=arr[i];

return（max）;

}

intmain（）

{

intarray[2][5]={{1,3,6,7},{2,4,16,8}};

int*b=（int*）array;

cout<

cout<

return0;

}

输出结果：

3.写出下面程序的输出结果（每空2分，共6分）

#include

usingnamespacestd;

templateclassTAdd{

Tx,y;

public:

TAdd（Ta,Tb）

{x=a;y=b;}

Tadd（）

{returnx+y;}

};

intmain（）

{

TAddA（5,6）;

TAddB（2.4,5.8）;

TAddC（2.4,5.8）;

cout<<"s1="<

cout<<"s2="<

cout<<"s3="<

return0;

}

输出结果：

4.写出下面程序的输出结果（每空2分，共12分）

#include

#include

usingnamespacestd;

classStudent{

private:

intnum;

stringname;

charsex;

public:

Student（intn,stringnam,chars）

{

num=n;

name=nam;

sex=s;

cout<<"Constructor"<

}

~Student（）

{

cout<<"Destructor"<

}

voiddisplay（）

{

cout<<"num:

"<

"<

"<

}

};

intmain（）

{

Studentstud1（10010,"Wang_li",'f'）;

stud1.display（）;

Studentstud2（10011,"Zhang_fun",'m'）;

stud2.display（）;

return0;

}

输出结果：

5.写出下面程序的输出结果（每空2分，共6分）

#include

usingnamespacestd;

classB

{

public:

virtualvoidfun1（）{cout<<"B:

:

fun1（）"<

virtualvoidfun2（）{cout<<"B:

:

fun2（）"<

voidfun3（）{cout<<"B:

:

fun3（）"<

};

classD:

publicB

{

public:

voidfun1（）{cout<<"D:

:

fun1（）"<

voidfun2（）{cout<<"D:

:

fun2（）"<

voidfun3（）{cout<<"D:

:

fun3（）"<

};

voidmain（）

{

B*pb;

Dd;

pb=&d;

pb->fun1（）;

pb->fun2（）;

pb->fun3（）;

}

输出结果：

6.请根据程序解密字符串。

（每空2分，共4分）

#include

usingnamespacestd;

voiddesecret（char*s）{

while（*s!

='\0'）{

if（*s>=65&&*s<=90||*s>=97&&*s<=122）//判断*s是否为英文字母

*s=*s+2;

s++;

}

}

intmain（）{

charst[]="Ucjamkcrmmspqafmmj";

cout<

desecret（st）;

cout<

return0;

}

输出结果：

四、完善程序（每空2分，共30分）

1．编一个冒泡排序的成员函数模板实现降序排序。

//使用字符串类string

#include

#include

usingnamespacestd;

templateclassOrderedlist{

intmaxsize;

intlast;

Tslist[size];

public:

Orderedlist（）{last=-1;maxsize=size;}

voidBubbleSort（）;

boolInsert（T&elem,inti）;

};

//Insert函数实现将元素elem插入到序列中第i个位置（第一个元素位置为0），并保持序列元素的连续性。

提示：

先判断i的有效性。

templateboolOrderedlist:

:

Insert（T&elem,inti）{

if（

（1））returnfalse;

else{

last++;

for（intj=last;j>i;j--）

（2）;

slist[i]=elem;

returntrue;

}

}

//BubbleSort函数实现降序冒泡排序

templatevoidOrderedlist:

:

BubbleSort（）{

boolnoswap;

inti,j;

Ttemp;

for（（3））{//从上往下冒泡

noswap=true;

for（j=0;j

if（（4））{//降序排列

temp=slist[j];

slist[j]=slist[j+1];

slist[j+1]=temp;

noswap=false;

}

}

if（（5））break;

}

}

intmain（）{

constinth=8;

inti;

Orderedlistordlist;

stringn[h];

stringsp[h]={"江苏","重庆","陕西","北京","天津","上海","浙江","安徽"};

for（i=0;i

for（i=0;i

ordlist.BubbleSort（）;

return0;

}

2．下列程序的运行结果如下：

Program1Print（）called.

Program2Print（）called.

根据结果将程序补充完整。

#include

usingnamespacestd;

classBase

{

public:

Base（inti）{b=i;}

（6）;

protected:

intb;

};

classProgram1:

publicBase

{

public:

（7）

voidPrint（）

{

cout<<"Program"<

}

};

classProgram2:

publicBase

{

public:

（8）

voidPrint（）

{

cout<<"Program"<

}

};

voidfun（（9））

{

obj->Print（）;

}

intmain（）

{

Program1*d1=newProgram1

（1）;

（10）;

fun（d1）;

fun（d2）;

return0;

}

3.完善单链表类模板相关函数

#include

usingnamespacestd;

templateclassList;

templateclassNode{

Tinfo;//数据域

Node*link;//指针域

public:

Node（）;//生成头结点的构造函数

Node（constT&data）;//生成一般结点的构造函数

voidInsertAfter（Node*P）;//在当前结点后插入一个结点

Node*RemoveAfter（）;//删除当前结点的后继结点，返回该结点备用

T&Getinfo（）;//增加取数据域函数

friendclassList;

};

templateNode:

:

Node（）{link=NULL;}

templateNode:

:

Node（constT&data）{

info=data;

link=NULL;

}

templatevoidNode:

:

InsertAfter（Node*p）{

p->link=link;

link=p;

}

templateNode*Node:

:

RemoveAfter（）{

Node*tempP=link;

if（link==NULL）tempP=NULL;

elselink=tempP->link;

returntempP;

}

templateT&Node:

:

Getinfo（）{returninfo;}

//定义链表类

templateclassList{

Node*head,*tail;//链表头指针和尾指针

public:

List（）;//构造函数，生成头结点（空链表）

~List（）;//析构函数

List&operator=（List&）;

voidMakeEmpty（）;//清空一个链表，只余表头结点

voidInsertFront（Node*p）;//可用来向前生成链表，在表头插入一个结点

voidInsertRear（Node*p）;//可用来向后生成链表，在表尾添加一个结点

voidInsertOrder（Node*p）;//按升序生成链表

};

templateList:

:

List（）

{

head=tail=newNode（）;

}

templateList:

:

~List（）

{

MakeEmpty（）;

deletehead;

}

//将当前链表清空

templatevoidList:

:

MakeEmpty（）{

Node*tempP;

while（head->link!

=NULL）{

tempP=head->link;

（11）;//把头结点后的第一个节点从链中脱离

deletetempP;

}

tail=head;//表头指针与表尾指针均指向表头结点，表示空链

}

//链表赋值运算符

templateList&List:

:

operator=（（12））

{

Node*TempP=ls.head->link,*P1;

（13）;

while（TempP!

=NULL）{

P1=newNode（TempP->info）;

//向后生成当前链表

（14）;

tail->link=P1;

tail=P1;

（15）;

}

return*this;

}

templatevoidList:

:

InsertFront（Node*p）{

p->link=head->link;

head->link=p;

if（tail==head）tail=p;

}

templatevoidList:

:

InsertRear（Node*p）{

p->link=tail->link;

tail->link=p;

tail=p;

}

templatevoidList:

:

InsertOrder（Node*p）{

Node*tempP=head->link,*tempQ=head;

//tempQ指向tempP前面的一个节点

while（tempP!

=NULL）{

if（p->infoinfo）break;

//找第一个比插入结点大的结点,由tempP指向

tempQ=tempP;

tempP=tempP->link;

}

tempQ->InsertAfter（p）;//插在tempP指向结点之前，tempQ之后

if（tail==tempQ）tail=tempQ->link;

}

09-10-3-程序设计及算法语言（电类）Ⅱ-B卷（答案）

一、选择题（每题1分，共10分）

1

2

3

4

5

6

7

8

9

10

B

A

D

C

B

A

C

D

B

D

二、填空题（每空1分，共20分）

1.小用

2.有序

3.8，3，5

4.公有继承、私有继承、保护继承

5.直接插入

345598217643

6.关键字operator和该运算符当前对象该函数的参数

7.深析构函数

8.cincoutcerrclog

9.!

fd

三、阅读程序,根据要求填空：

（共40分）

1.写出下面程序的输出结果（每空1~2分，本题8分）

输出结果：

constructoriscalled（1分）

constructoriscalled（1分）

n=10,k=2（2分）

n=20,k=2（2分）

destructoriscalled（1分）

destructoriscalled（1分）

2.写出下面程序的输出结果（每空2分，共4分）

输出结果：

0

16

3.写出下面程序的输出结果（每空2分，共6分）

输出结果：

s1=11

s2=7

s3=8.2

4.写出下面程序的输出结果（每空2分，共12分）

输出结果：

Constructor

num:

10010name:

Wang_lisex:

f

Constructor