C++期末热身第二部分.docx
《C++期末热身第二部分.docx》由会员分享，可在线阅读，更多相关《C++期末热身第二部分.docx（34页珍藏版）》请在冰豆网上搜索。
C++期末热身第二部分
C++：
第二部分
一、选择题
1、下列对派生类的描述中，（4）是错误的。
①一个派生类可以作为另一个派生类的基类
②派生类至少有一个基类
1派生类的成员除了它自已的成员外，还包含了它的基类的成员
2派生类中继承的基类成员的访问权限在派生类中保持不变
2、对基类和派生类的描述中，（4）是错的。
①派生类是基类的具体化②派生类是基类的子集
③派生类是基类定义的延续④派生类是基类的组合
3、派生类的构造函数的成员初始化列表中，不能包含
（2）。
①基类的构造函数②派生类中子对象的初始化
③基类的子对象初始化④派生类中一般数据成员的初始化
4、设置虚基类的目的是
（2）。
①简化程序②消除二义性③提高运行效率④减少目标代码
5、关于子类型的描述中，（4）是错的。
①子类型就是指派生类是基类的子类型
②一种类型当它至少提供了另一种类型的行为，则这种类型是另一种类型的子类型
③在公有继承下，派生类是基类的子类型
④子类型关系是不可逆的
6、已知一个类A，（3）是指向类A成员函数的指针。
假设类A有3个公有成员：
Voidf1（int）,voidf2（int）和inta。
1A*p；②intA:
:
*pc=&A:
:
a；③voidA:
:
*pa（）；④A*pp；
7、已知f1（int）是类A的公有成员函数，p是指向成员函数f1（）的指针，采用
（2）是
正确的
1p＝f1；②p＝A:
:
f1；③p＝A:
:
f1（）；④p＝f1（）；
8、已知：
p是一个指向类A数据成员m的指针，a1是类A的一个对象。
如果要给m赋值
为5，（3）是正确的。
1a1.p=5；②a1->p=5；③a1.*p=5；④*a1.p=5；
9、已知类A中一个成员函数说明如下：
voidSet（A&a）
其中，A&a的含意是（3）。
1指向类A的指针为a
②将A的地址值赋给变量Set
③a是类A的对象的引用，用来作函数Set（）的形参
④变量A与a按位相与作为函数Set（）的参数
10、有以下类的说明，请指出错误的地方ABCD
classCSample
{
private:
inta=2.5;（A）
CSample;（B）
public:
CSample（intval）;（C）
~CSample;（D）
}；
11、下面程序的输出结果是（ 1 ）
#include
usingnamespacestd;
classpoint
{
public:
voidpoi（intpx=10,intpy=10）
{x=px;y=py;}
getpx（）
{returnx;}
getpy（）
{returny;}
private:
intx,y;
};
intmain（）
{
pointp,q;
p.poi（）;
q.poi（15,15）;
cout<<“p点的坐标是：
”<cout<cout<<“q点的坐标是：
”<cout<return0;
}
①p点的坐标是：
10,10②p点的坐标是：
0,0
q点的坐标是：
15,15q点的坐标是：
15,15
③p点的坐标是：
0,0④p点的坐标是：
10,10
q点的坐标是：
0,0q点的坐标是：
10,10
12、下列关于对象数组的描述中，（4）是错误的。
①对象数组的下标是从0开始的②对象数组的数组名是一个常量指针
2对象数组的每个元素是同一个类的对象④对象数组只能赋初值，而不能被赋值
13、下列定义中，
（2）是定义指向数组的指针p。
①int*p[5]②int（*p）[5]③（int*）p[5]④int*p[]
14、具有转换函数功能的构造函数，应该是
（2）。
①不带参数的构造函数②带有一个参数的构造函数
③带有两个以上参数的构造函数④默认构造函数
15、关于多继承二义性的描述中，（3）是错的。
①一个派生类的两个基类中都有某个同名成员，在派生类中对这个成员的访问可能出现二义性
②解决二义性的最常用的方法是对成员名的限定法
③基类和派生类中同时出现的同名函数，也存在二义性问题
④一个派生类是从两个基类派生来的，而这两个基类又有一个共同点基类，对该基类
成员进行访问时，有可能存在二义性
16、下列关于运算符重载的描述中，（4）是正确的。
①运算符重载可以改变操作数的个数②运算符重载可以改变优先级
③运算符重载可以改变结合性④运算符重载不可以改变语法结构
/17、关于动态联编的下列描述中，（）是错误的。
①动态联编是一虚函数我基础的
②动态联编是在运行时确定所调用的函数代码的
③动态联编调用函数操作是用指向对象的指针或对象引用
④动态联编是在编译时确定操作函数的
18、关于虚函数的描述中，（3）是正确的。
①虚函数是一个static类型的成员函数②虚函数是一个非成员函数
③基类中说明了虚函数后，派生类中其对应的函数可不必说明为虚函数
④派生类的虚函数与基类的虚函数具有不同的参数个数和类型
19、下列描述中，（4）是抽象类的特性。
①可以说明虚函数②可以进行构造函数重载
3可以定义友元函数④不能说明其对象
20、在多继承中，公有派生和私有派生对于基类成员在派生类中的可访问性与单继承的规则
（1）。
①完全相同②完全不同③部分相同，部分不同④以上都不对
21、（3）是一个在基类中说明的虚函数，它在该基类中没有定义，但要求任何派生类都必须定义自己的版本。
①虚析构函数②虚构造函数③纯虚函数④静态成员函数
22、如果一个类至少有一个纯虚函数，那么就称该类为
（1）。
①抽象类②虚基类③派生类④以上都不对
二、判断题
1、一个类的构造函数中可以不包含对其子对象的初始化。
（T）
2、派生类是从基类派生出来，它不能再生成新的派生类。
（F）
3、在公有继承中，基类中的公有成员和私有成员在派生类中都是可见的。
（F）
4、单继承情况下，派生类中对基类成员的访问也会出现二义性。
（F）
5、构造函数可以被继承。
（T）
6、析构函数不能被继承。
（F）
7、解决多继承情况下出现二义性的方法之一是使用成员名限定法。
（T）
8、子类型是不可逆的。
（F）
9、派生类是它的基类的组合。
（F）
/10、只要是类M继承了类N，就可以说类M是类N的子类型。
（T）
11、如果A类型是B类型的子类型，则A类型必然适应于B类型。
（T）
12、重载运算符保持原运算符的优先级和结合性不变。
（T）
13、构造函数说明为纯虚函数是没有意义的。
（T）
14、抽象类是指一些没有说明对象的类。
（F）
15、动态联编是在运行时选定调用的成员函数的。
（T）
三、填空题
1、以下程序的执行结果是567。
#include
usingnamespacestd;
classSample
{
intx;
public:
voidsetx（inti）{x=i;}
intputx（）{returnx;}
};
intmain（）
{
Sample*p;
SampleA[3];
A[0].setx（5）;
A[1].setx（6）;
A[2].setx（7）;
for（intj=0;j<3;j++）
{
p=&A[j];
cout<putx（）<<”“;
}
cout<return0;
}
2、以下程序的执行结果是构造函数。
i=10
i=20。
#include
usingnamespacestd;
classSample
{
public:
Sample（）
{
cout<<”构造函数。
”<}
};
voidfn（inti）
{
staticSamplec;
cout<<”i=”<}
intmain（）
{
fn（10）;
fn（20）;
return0;
}
3、以下程序的执行结果是x=5。
#include
usingnamespacestd;
classA
{
public:
intx;
voidfun（inti）{x=i;}
};
intmain（）
{
Ac;
intA:
:
*p=&A:
:
x;
c.*p=2;
void（A:
:
*pfun）（int）=A:
:
fun;
（c.*pfun）（5）;
cout<<”x=”<return0;
}
4、以下程序的执行结果是fun1:
7
fun2:
15。
#include
usingnamespacestd;
classA
{
public:
intx;
A（inti）{x=i;}
voidfun1（intj）{x+=j;cout<<”fun1:
”<voidfun2（intj）{x+=j;cout<<”fun2:
”<};
intmain（）
{
Ac1
（2）,c2（5）;
void（A:
:
*pfun）（int）=A:
:
fun1;
（c1.*pfun）（5）;
pfun=A:
:
fun2;
（c2.*pfun）（10）;
return0;
}
5、以下程序的执行结果是97。
#include
usingnamespacestd;
classSample
{
intx;
public:
Sample（）{};
voidsetx（inti）{x=i;}
friendintfun（SampleB[],intn）
{
intm=0;
for（inti=0;iif（B[i].x>m）m=B[i].x;
returnm;
}
};
intmain（）
{
SampleA[10];
intArr[]={90,87,42,78,97,84,60,55,78,65};
for（inti=0;i<10;i++）
A[i].setx（Arr[i]）;
cout<return0;
}
6、以下程序的执行结果是1
3。
#include
usingnamespacestd;
classA
{
inta;
public:
voidseta（intx）{a=x;}
voidshowa（）{cout<};
classB
{
intb;
public:
voidsetb（intx）{b=x;}
voidshowb（）{cout<};
classC:
publicA,privateB
{
private:
intc;
public:
voidsetc（intx,inty,intz）
{
c=z;
seta（x）;
setb（y）;
}
voidshowc（）{cout<};
intmain（）
{
Cc;
c.seta
（1）;
c.showa（）;
c.setc（1,2,3）;
c.showc（）;
return0;
}
7、以下程序的执行结果是（1,2）
5,6
（6,9）。
#include
usingnamespacestd;
classA
{
public:
A（inti,intj）{a=i;b=j;}
voidmove（intx,inty）
{
a+=x;b+=y;
}
voidshow（）
{
cout<<”（“<}
private:
inta,b;
};
classB:
privateA
{
public:
B（inti,intj,intk,intl）:
A（i,j）
{
x=k;y=l;
}
voidshow（）
{
cout<}
voidfun（）{move（3,5）;}
voidf1（）{A:
:
show（）;}
private:
intx,y;
};
intmain（）
{
Ae（1,2）;
e.show（）;
Bd（3,4,5,6）;
d.fun（）;
d.show（）;
d.f1（）;
return0;
}
8、以下程序的执行结果是a=0b=0c=0
a=1b=0c=0
a=1b=3c=0
a=1b=3c=5。
#include
usingnamespacestd;
classA
{
public:
A（）{a=0;b=0;}
A（inti）{a=i;b=0;}
A（inti,intj）{a=i;b=j;}
voiddisplay（）{cout<<"a="<private:
inta;
intb;
};
classB:
publicA
{
public:
B（）{c=0;}
B（inti）:
A（i）{c=0;}
B（inti,intj）:
A（i,j）{c=0;}
B（inti,intj,intk）:
A（i,j）{c=k;}
voiddisplay1（）
{display（）;
cout<<"c="<}
private:
intc;
};
intmain（）
{Bb1;
Bb2
（1）;
Bb3（1,3）;
Bb4（1,3,5）;
b1.display1（）;
b2.display1（）;
b3.display1（）;
b4.display1（）;
return0;
}
9、以下程序的执行结果是30,30。
#include
usingnamespacestd;
classPoint
{
intx,y;
public:
Point（intvx,intvy）{x=vx;y=vy;}
Point（）{x=0;y=0;}
Pointoperator+（Pointp1）
{
Pointp;
intpx=x+p.x;
intpy=y+p.y;
returnPoint（px,py）;
}
Pointoperator-（Pointp1）
{
Pointp;
intpx=x-p1.x;
intpy=y-p1.y;
returnPoint（px,py）;
}
voidprint（）
{
cout<}
};
intmain（）
{
Pointp1（10,10）,p2（20,20）;
p1=p1+p2;
p1.print（）;
return0;
}
10、以下程序的执行结果是baseclass
deriveclass
derive2class。
#include
usingnamespacestd;
classbase
{
public:
virtualvoidwho（）
{
cout<<”baseclass”<}
};
classderive:
publicbase
{
public:
voidwho（）
{
cout<<”deriveclass”<}
};
classderive2:
publicbase
{
public:
voidwho（）
{
cout<<”derive2class”<}
};
intmain（）
{
baseobj1,*p;
deriveobj2;
derive2obj3;
p=&obj1;
p->who（）;
p=&obj2;
p->who（）;
p=&obj3;
p->who（）;
return0;
}
11、以下程序的执行结果是f1functionofbase
f2functionofbase
f3functionofbase
f1functionofderive
f2functionofbase
f4functionofderive。
#include
usingnamespacestd;
classbase
{
public:
virtualvoidf1（）
{
cout<<”f1functionofbase”<}
virtualvoidf2（）
{
cout<<”f2functionofbase”<}
virtualvoidf3（）
{
cout<<”f3functionofbase”<}
virtualvoidf4（）
{
cout<<”f3functionofbase”<}
};
classderive:
publicbase
{
voidf1（）
{
cout<<”f1functionofderive”<}
voidf2（intx）
{
cout<<”f2functionofderive”<}
voidf4（）
{
cout<<”f4functionofderive”<}
};
intmain（）
{
baseobj1,*p;
deriveobj2;
p=&obj1;
p->f1（）;
p->f2（）;
p->f3（）;
p=&obj2;
p->f1（）;
p->f2（）;
p->f4（）;
return0;
}
12、以下程序的执行结果是（10,20）
（13,23）
（16,26）。
#include
classPoint
{
public:
Point（）{x=0;y=0;}
Point（unsignedx,unsignedy）
{
Point:
:
x=x;
Point:
:
y=y;
}
unsignedgetx（）{returnx;}
unsignedgety（）{returny;}
voidprint（）
{
cout<<”Point（“<}
friendPointoperator+（Point&pt,intnoffset）;
friendPointoperator+（intnoffset,Point&pt）;
private:
unsignedx,y;
};
Pointoperator+（Point&pt,intnoffset）
{
Pointptemp=pt;
ptemp.x+=noffset;
ptemp.y+=noffset;
returnptemp;
}
Pointoperator+（intnoffset,Point&pt）
{
Pointptemp=pt;
ptemp.x+=noffset;
ptemp.y+=noffset;
returnptemp;
}
intmain（）
{
Pointpt（10,20）;
pt.print（）;
pt=pt+3;
pt.print（）;
pt=3+pt;
pt.print（）;
return0;
}
四、程序分析题
1、分析下列程序的输出结果（注：
除了给出结果外，还要进行简单分析）
#include
usingnamespacestd;
classL
{
public:
voidInitL（intx,inty）{X=x;Y=y;}
voidMove（intx,inty）{X+=x;Y+=y;}
intGetX（）{returnX;}
intGetY（）{returnY;}
private:
intX,Y;
};
classR:
publicL
{
public:
voidInitR（intx,inty,intw,inth）
{
InitL（x,y）;
W=w;
H=h;
}
intGetW（）{returnW;}
intGetH（）{returnH;}
private:
intW,H;
};
classV:
publicR
{
public:
voidfun（）{Move（3,2）;}
};
intmain（）
{
Vv;
v.InitR（10,20,30,40）;
v.
升级会员 