笔试B卷09103C++电类ⅡWord文档下载推荐.docx
《笔试B卷09103C++电类ⅡWord文档下载推荐.docx》由会员分享，可在线阅读，更多相关《笔试B卷09103C++电类ⅡWord文档下载推荐.docx（18页珍藏版）》请在冰豆网上搜索。
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（）函数是顺序表的成员函数。
template<
typenameT,intsize>
voidOrderedlist<
T,size>
:
Sort（）{
Ttemp;
inti,j;
for（i=1;
i<
=last;
i++）{
temp=slist[i];
j=i;
while（j>
0&
&
temp<
slist[j-1]）{
slist[j]=slist[j-1];
j--;
//查找与移动同时做
}
slist[j]=temp;
}
}
该成员函数用到的是排序。
若未排序前的数据为：
553498217643
for循环执行完第一次后的数据顺序为：
6.运算符重载时，其函数名由构成。
成员函数重载双目运算符时，左操作数是，右操作数是。
7.对含有动态分配的数据成员的类对象应该采用复制，动态分配的资源通常要求在中释放，
8.全局标准流对象有、、和。
9.通过表达式可以判断文件流fd是否正确打开。
三、阅读程序,根据要求填空：
（共40分）
1.写出下面程序的输出结果（每空1~2分，本题8分）
#include<
iostream>
usingnamespacestd;
classCSample{
intn;
staticintk;
public:
CSample（inti）
{
cout<
<
"
constructoriscalled\n"
;
n=i;
k++;
~CSample（）
destructoriscalled\n"
voiddisp（）
n="
n<
k="
k<
endl;
};
intCSample:
k=0;
intmain（）
{
CSamplea（10）,b（20）;
a.disp（）;
b.disp（）;
return0;
输出结果：
（1分）
（1分）
（2分）
2.写出下面程序的输出结果（每空2分，共4分）
intMAX（int*arr,intn）
inti,max=arr[0];
for（i=0;
i<
n;
i++）
if（arr[i]>
max）
max=arr[i];
return（max）;
intarray[2][5]={{1,3,6,7},{2,4,16,8}};
int*b=（int*）array;
cout<
b[4]<
MAX（b,2*5）<
'
\n'
return0;
3.写出下面程序的输出结果（每空2分，共6分）
template<
typenameT>
classTAdd{
Tx,y;
public:
TAdd（Ta,Tb）
{x=a;
y=b;
Tadd（）
{returnx+y;
TAdd<
int>
A（5,6）;
B（2.4,5.8）;
double>
C（2.4,5.8）;
s1="
A.add（）<
cout<
s2="
B.add（）<
s3="
C.add（）<
4.写出下面程序的输出结果（每空2分，共12分）
#include<
string>
classStudent{
private:
intnum;
stringname;
charsex;
Student（intn,stringnam,chars）
num=n;
name=nam;
sex=s;
Constructor"
~Student（）
Destructor"
voiddisplay（）
num:
"
num<
name:
name<
sex:
sex<
intmain（）
Studentstud1（10010,"
Wang_li"
'
f'
）;
stud1.display（）;
Studentstud2（10011,"
Zhang_fun"
m'
stud2.display（）;
5.写出下面程序的输出结果（每空2分，共6分）
classB
virtualvoidfun1（）{cout<
B:
fun1（）"
virtualvoidfun2（）{cout<
fun2（）"
voidfun3（）{cout<
fun3（）"
classD:
publicB
voidfun1（）{cout<
D:
voidfun2（）{cout<
voidmain（）
B*pb;
Dd;
pb=&
d;
pb->
fun1（）;
fun2（）;
fun3（）;
6.请根据程序解密字符串。
（每空2分，共4分）
voiddesecret（char*s）{
while（*s!
='
\0'
）{
if（*s>
=65&
*s<
=90||*s>
=97&
=122）//判断*s是否为英文字母
*s=*s+2;
s++;
intmain（）{
charst[]="
Ucjamkcrmmspqafmmj"
st<
desecret（st）;
四、完善程序（每空2分，共30分）
1．编一个冒泡排序的成员函数模板实现降序排序。
//使用字符串类string
classOrderedlist{
intmaxsize;
intlast;
Tslist[size];
Orderedlist（）{last=-1;
maxsize=size;
voidBubbleSort（）;
boolInsert（T&
elem,inti）;
//Insert函数实现将元素elem插入到序列中第i个位置（第一个元素位置为0），并保持序列元素的连续性。
提示：
先判断i的有效性。
boolOrderedlist<
Insert（T&
elem,inti）{
if（
（1））returnfalse;
else{
last++;
for（intj=last;
j>
i;
j--）
（2）;
slist[i]=elem;
returntrue;
//BubbleSort函数实现降序冒泡排序
voidOrderedlist<
BubbleSort（）{
boolnoswap;
for（（3））{//从上往下冒泡
noswap=true;
for（j=0;
j<
j++）{
if（（4））{//降序排列
temp=slist[j];
slist[j]=slist[j+1];
slist[j+1]=temp;
noswap=false;
}
if（（5））break;
constinth=8;
inti;
Orderedlist<
string,100>
ordlist;
stringn[h];
stringsp[h]={"
江苏"
"
重庆"
陕西"
北京"
天津"
上海"
浙江"
安徽"
h;
i++）n[i]=sp[i];
i++）ordlist.Insert（n[i],i）;
//建立顺序表
ordlist.BubbleSort（）;
2．下列程序的运行结果如下：
Program1Print（）called.
Program2Print（）called.
根据结果将程序补充完整。
classBase
Base（inti）{b=i;
（6）;
protected:
intb;
classProgram1:
publicBase
（7）
voidPrint（）
Program"
<
b<
Print（）called."
classProgram2:
（8）
voidfun（（9））
obj->
Print（）;
Program1*d1=newProgram1
（1）;
（10）;
fun（d1）;
fun（d2）;
3.完善单链表类模板相关函数
classList;
classNode{
Tinfo;
//数据域
Node<
T>
*link;
//指针域
Node（）;
//生成头结点的构造函数
Node（constT&
data）;
//生成一般结点的构造函数
voidInsertAfter（Node<
*P）;
//在当前结点后插入一个结点
*RemoveAfter（）;
//删除当前结点的后继结点，返回该结点备用
T&
Getinfo（）;
//增加取数据域函数
friendclassList<
Node（）{link=NULL;
Node（constT&
data）{
info=data;
link=NULL;
voidNode<
InsertAfter（Node<
*p）{
p->
link=link;
link=p;
Node<
*Node<
RemoveAfter（）{
*tempP=link;
if（link==NULL）tempP=NULL;
elselink=tempP->
link;
returntempP;
Getinfo（）{returninfo;
}
//定义链表类
classList{
*head,*tail;
//链表头指针和尾指针
List（）;
//构造函数，生成头结点（空链表）
~List（）;
//析构函数
List&
operator=（List<
voidMakeEmpty（）;
//清空一个链表，只余表头结点
voidInsertFront（Node<
*p）;
//可用来向前生成链表，在表头插入一个结点
voidInsertRear（Node<
//可用来向后生成链表，在表尾添加一个结点
voidInsertOrder（Node<
*p）;
//按升序生成链表
List<
List（）
head=tail=newNode<
（）;
~List（）
MakeEmpty（）;
deletehead;
//将当前链表清空
voidList<
MakeEmpty（）{
*tempP;
while（head->
link!
=NULL）{
tempP=head->
（11）;
//把头结点后的第一个节点从链中脱离
deletetempP;
tail=head;
//表头指针与表尾指针均指向表头结点，表示空链
//链表赋值运算符
List<
operator=（（12））
*TempP=ls.head->
link,*P1;
（13）;
while（TempP!
=NULL）{
P1=newNode<
（TempP->
info）;
//向后生成当前链表
（14）;
tail->
link=P1;
tail=P1;
（15）;
return*this;
InsertFront（Node<
*p）{
link=head->
head->
link=p;
if（tail==head）tail=p;
InsertRear（Node<
link=tail->
tail->
tail=p;
InsertOrder（Node<
*tempP=head->
link,*tempQ=head;
//tempQ指向tempP前面的一个节点
while（tempP!
if（p->
info<
tempP->
info）break;
//找第一个比插入结点大的结点,由tempP指向
tempQ=tempP;
tempP=tempP->
tempQ->
InsertAfter（p）;
//插在tempP指向结点之前，tempQ之后
if（tail==tempQ）tail=tempQ->
09-10-3-程序设计及算法语言（电类）Ⅱ-B卷（答案）
1
2
3
4
5
6
7
8
9
10
B
A
D
C
二、填空题（每空1分，共20分）
1.小用
2.有序
3.8，3，5
4.公有继承、私有继承、保护继承
5.直接插入
345598217643
6.关键字operator和该运算符当前对象该函数的参数
7.深析构函数
8.cincoutcerrclog
9.!
fd
constructoriscalled（1分）
constructoriscalled（1分）
n=10,k=2（2分）
n=20,k=2（2分）
destructoriscalled（1分）
destructoriscalled（1分）
0
16
s1=11
s2=7
s3=8.2
Constructor
num:
10010name:
Wang_lisex:
f
Constructor
升级会员 