C++随堂测试继承多态重载答案.docx
《C++随堂测试继承多态重载答案.docx》由会员分享，可在线阅读，更多相关《C++随堂测试继承多态重载答案.docx（32页珍藏版）》请在冰豆网上搜索。
C++随堂测试继承多态重载答案
C++随堂测试（继承、多态、重载）
一、选择题（）
1.在C++中，类与类之间的继承关系具有（C）
A）自反性B）对称性C）传递性D）反对称性
2.在保护继承的情况下，基类的成员（私有的除外）在派生类中的访问权限（C）
A）受限制B）保持不变C）受保护D）不受保护
3.在下列运算符中,不能重载的是（B）
A.！
B.sizeofC.newD.delete
4.不能用友元函数重载的是（A）。
A.=B.==C.<=D.++
5．在哪种派生方式中，派生类可以访问基类中的protected成员（B）
A）public和privateB）public、protected和private
C）protected和privateD）仅protected
6.下列函数中,不能重载运算符的函数是（B）。
A.成员函数B.构造函数C.普通函数D.友元函数
7.下面叙述错误的是（A）。
A）基类的protected成员在派生类中仍然是protected的
B）基类的protected成员在public派生类中仍然是protected的
C）基类的protected成员在private派生类中是private的
D）基类的protected成员不能被派生类的对象访问
8.如果表达式++i*k时中的”++”和”*”都是重载的友元运算符，则采用运算符函数调用格式，该表达式还可表示为（B）。
A．operator*（i.operator++（）,k）B．operator*（operator++（i）,k）
C．i.operator++（）.operator*（k）D．k.operator*（operator++（i））
9.下面叙述错误的是（C）。
A）派生类可以使用private派生
B）对基类成员的访问必须是无二义性的
C）基类成员的访问能力在派生类中维持不变
D）赋值兼容规则也适用于多继承的组合
10.下列虚基类的声明中，正确的是：
（B）
A）classvirtualB:
publicAB）classB:
virtualpublicA
C）classB:
publicAvirtualD）virtualclassB:
publicA
11.已知在一个类体中包含如下函数原型：
VOLUMEoperator-（VOLUME）const；下列关于这个函数的叙述中，错误的是（B）。
A．这是运算符-的重载运算符函数
B．这个函数所重载的运算符是一个一元运算符
C．这是一个成员函数
D．这个函数不改变数据成员的值
12.假设A为抽象类，下列声明（B）是正确的
A）Afun（int）;B）A*p;C）intfun（A）;D）AObj;
13.在表达式x＋y*z中，+是作为成员函数重载的运算符，*是作为非成员函数重载的运算符。
下列叙述中正确的是（C）。
A．operator+有两个参数，operator*有两个参数
B．operator+有两个参数，operator*有一个参数
C．operator+有一个参数，operator*有两个参数
D．operator+有一个参数，operator*有一个参数
14.实现运行时的多态性要使用（D）。
A）重载函数B）构造函数
C）析构函数D）虚函数
15.当一个派生类仅有protected继承一个基类时，基类中的所有公有成员成为派生类的（C）
A）public成员B）private成员C）protected成员D）友元
16.下面函数原型声明中，（C）声明了fun为普通虚函数
A）voidfun（）=0;B）virtualvoidfun（）=0;
C）virtualvoidfun（）;D）virtualvoidfun（）{};
17.关于虚函数的描述中,正确的是（D）。
A）虚函数是一个静态成员函数
B）虚函数是一个非成员函数
C）虚函数既可以在函数说明时定义,也可以在函数实现时定义
D）派生类的虚函数与基类中对应的虚函数具有相同的参数个数和类型
18、采用函数重载的目的在于：
（D）
A、实现共享B、减少空间
C、提高速度D、使用方便,提高可读性
19.若类X和类Y的定义如下：
classX
{inta,b;
public:
voidfx（）;
}；
classY:
publicX
{intc;
public:
voidfy（）;
};
voidY:
:
fy（）{c=a*b;}
则上述代码中，B是非法的语句。
A、voidfx（）;B、k=a*b;C、voidfy（）;D、intc;
20.以下程序的输出结果为是（B）。
#include
classA
{public:
intn;};
classB:
virtualpublicA{};
classC:
virtualpublicA{};
classD:
publicB,publicC
{intgetn（）{returnB:
:
n;}};
voidmain（）
{Dd;d.B:
:
n=10;d.C:
:
n=20;
cout<:
n<<","<:
n<}
A、10，20B、20，20C、10，10D、输出有二义性，不确定
二、填空题
1.C++中多态性包括两种多态性：
编译时的和运行时的。
前者是通过函数和运算符的重载实现的，而后者是通过类继承关系和虚函数来实现的。
2.派生类对基类的继承有三种方式:
_public_、_protected和__private_。
3..运算符重载是对已有的运算符赋予多重含义，使同一个运算符在作用于不同类型对象时导致不同的行为。
运算符重载的实质是函数重载，是类的多态性特征。
4．类继承中，缺省的继承方式是__private__。
当用public继承从基类派生一个类时，基类的public成员成为派生类的public成员，protected成员成为派生类的protected成员，对private成员是不可访问。
5.如果类α继承了类β，则类α称为基类，而类β称为派生类。
派生类的对象可作为基类的对象处理，
三、程序阅读
1.写出下面这段程序的运行结果
4.1#include
#usingnamesoacestd;
classT
{public:
T（）{a=0;b=0;c=0;}
T（inti,intj,intk）
{a=i;b=j;c=k;}
voidget（int&i,int&j,int&k）
{i=a;j=b;k=c;}
Toperator*（Tobj）;
private:
inta,b,c;
};
TT:
:
operator*（Tobj）
{Ttempobj;
tempobj.a=a*obj.a;
tempobj.b=b*obj.b;
tempobj.c=c*obj.c;
returntempobj;
}
intmain（）
{
Tobj1（1,2,3）,obj2（5,5,5）,obj3;
inta,b,c;
obj3=obj1*obj2;
obj3.get（a,b,c）;
cout<<”（obj1*obj2）:
\t”<<”a=”<（obj2*obj3）.get（a,b,c）;
cout<<“（obj2＊obj3）:
\t”<<“a=”<}
答案：
（obj1*obj2）:
a=5b=10c=15
（obj2*obj3）:
a=25b=50c=75
2.输出下面这段程序运行结果：
#include
usingnamespacestd;
classBase{
public:
Base（intc）{cout<<"基类带参构造函数"<~Base（）{cout<<"基类析构"<};
classDerived:
publicBase{
public:
Derived（intc）:
Base（c）//显式调用基类构造函数
{
cout<<"派生类带参构造函数"<}
~Derived（）{cout<<"派生类析构"<};
intmain（）
{
inti=9;
Derivedd1（i）;
return0;
}
答案：
基类带参构造函数9
派生类带参构造函数9
派生类析构
基类析构
一、编程题
1.设向量X=（x1,x2,…,xn）和Y=（y1,y2…,yn）,它们之间的加、减分别定义为：
X+Y=（x1+y1,x2+y2,…,xn+yn）
X-Y=（x1-y1,x2-y2,…,xn-yn）
编程序定义向量类Vector,重载运算符”+”、”-“、”=”,实现向量之间的加、减和赋值运算;用重载运算符”>>”、”<<”做向量的输入/输出操作。
注意检测运算的合法性。
答案：
#include
//usingnamespacestd;
classVector{
intvec[10];
public:
Vector（intv[10]）;
Vector（）;
Vector（Vector&）;
Vectoroperator+（Vector&）;
Vectoroperator-（Vector&）;
friendostream&operator<<（ostream&out,Vector&）;
};
Vector:
:
Vector（intv[10]）{
inti;
for（i=0;i<10;i++）vec[i]=v[i];
}
Vector:
:
Vector（）{
inti;
for（i=0;i<10;i++）vec[i]=0;
}
Vector:
:
Vector（Vector&v）{
inti;
for（i=0;i<10;i++）vec[i]=v.vec[i];
}
VectorVector:
:
operator+（Vector&v）{
Vectorz;
inti;
for（i=0;i<10;i++）
z.vec[i]=vec[i]+v.vec[i];
returnz;
}
VectorVector:
:
operator-（Vector&v）{
Vectorz;
inti;
for（i=0;i<10;i++）
z.vec[i]=vec[i]-v.vec[i];
returnz;
}
ostream&operator<<（ostream&out,Vector&v）{
for（inti=0;i<10;i++）
out<returnout;
}
voidmain（）{
inta[10]={-4,1,0,10,5,-9,8,13,6,2,};
intb[10]={-11,8,10,17,-6,9,6,7,12,5};
Vectorv1（a）,v2（b）,v3,v4;
v3=v1+v2;
v4=v2-v1;
cout<cout<}
2.定义一个Girl类和一个Boy类，这两个类中都有表示姓名、年龄的私有成员变量，
都要定义构造函数,析构函数是否定义根据类的数据成员定义情况而定.输出成员变量信息的公有成员函数voidprint（）;。
①根据要求定义相应的类。
②将Girl类作为Boy类的友元类，在Girl类中定义成员函数voidVisitBoy（Boy&）中访问Boy类引用参数的私有成员，如果Boy类中年龄成员值小于20,则一律改为20,其余情况下不用修改.
③定义一个普通函数voidVisitBoyGirl（constBoy&,constGirl&），作为以上两个类的友元函数，在其中直接访问其数据成员而非调用类的print函数,通过调用该函数输出男孩和女孩的信息。
④主函数的代码已给出,请将程序补充完整
intmain（）
{
Boyb1（"Nike",19）,b2（"Mike",32）;
Girlg（"Alice",18）;
b1.print（）;
b2.print（）;
g.print（）;
g.VisitBoy（b1）;
VisitBoyGirl（b1,g）;
return0;
}
答案：
#include
#include
usingnamespacestd;
classGirl;
classBoy
{
stringname;
intage;
intmoney;
public:
Boy（stringn,inta,intm）;
voidprint（）;
friendclassGirl;
friendvoidMemorialDay（constBoy&,constGirl&）;
};
classGirl
{
stringname;
intage;
intmoney;
public:
Girl（stringn,inta,intm）;
voidprint（）;
voidVisitBoy（Boy&）;
friendvoidMemorialDay（constBoy&,constGirl&）;
};
Boy:
:
Boy（stringn,inta,intm）
{
name=n;
age=a;
money=m;
}
voidBoy:
:
print（）
{
cout<}
Girl:
:
Girl（stringn,inta,intm）
{
name=n;
age=a;
money=m;
}
voidGirl:
:
print（）
{
cout<}
voidGirl:
:
VisitBoy（Boy&b）
{
if（b.money>100）{
inttemp=b.money-100;
b.money=100;
this->money+=100;
}
}
voidMemorialDay（constBoy&b,constGirl&g）
{
b.money=0;
cout<cout<}
intmain（）
{
Boyb1（"Nike",19）,b2（"Mike",22）;
Girlg（"Alice",18）;
b1.print（）;
b2.print（）;
g.print（）;
g.VisitBoy（b1）;
MemorialDay（b1,g）;
return0;
}
3.某公司雇员（employee）包括经理（manager），技术人员（technician）和销售员（salesman）。
开发部经理（developermanger），既是经理也是技术人员。
销售部经理（salesmanager），既是经理也是销售员。
编程实现工资管理。
（加分项：
实现最少一个类的拷贝构造函数）
以employ类为虚基类派生出manager，technician和salesman类；再进一步派生出developermanager和salesmanager类。
employee类的属性包括姓名、职工号、工资级别，月薪（实发基本工资加业绩工资）。
操作包括月薪计算函数（pay（）），该函数要求输入请假天数，扣去应扣工资后，得出实发基本工资。
technician类派生的属性有每小时附加酬金和当月工作时数，及研究完成进度系数。
业绩工资为三者之积。
也包括同名的pay（）函数，工资总额为基本工资加业绩工资。
salesman类派生的属性有当月销售额和酬金提取百分比，业绩工资为两者之积。
也包括同名的pay（）函数，工资总额为基本工资加业绩工资。
manager类派生属性有固定奖金额和业绩系数，业绩工资为两者之积。
工资总额也为基本工资加业绩工资。
而developermanager类，pay（）函数是将作为经理和作为技术人员业绩工资之和的一半作为业绩工资。
salesamanager类，pay（）函数则是经理的固定奖金额的一半，加上部门总销售额与提成比例之积，这是业绩工资。
答案：
#include
#include
usingnamespacestd;
staticintGrades[]={500,600,750,1000,1400,2000,2800,4000};
classemployee{
protected:
stringname;//姓名
intID;//职工号
intgrade;//工资级别
doublesalary;//月
doublebase_salary;//基本月薪
doublecareer_salary;//业绩工资
public:
employee（string="",int=0,int=0）;
virtualvoidpay（）;//月薪计算函数
voidshow（）;
doublegetsalary（）{returnsalary;}
doublegetbase_salary（）{returnbase_salary;}
doublegetcareer_salary（）{returncareer_salary;}
};
employee:
:
employee（stringnn,intid,intgr）{
name=nn;
ID=id;
grade=gr;
salary=0;//月薪
base_salary=0;//基本月薪
career_salary=0;//业绩工资
}
employee:
:
employee（employee&emp）{//拷贝构造函数
name=emp.name;
ID=emp.ID;
grade=emp.grade;
salary=emp.salary;//月薪
base_salary=emp.base_salary;//基本月薪
career_salary=emp.career_salary;//业绩工资
}
voidemployee:
:
show（）{
cout<}
voidemployee:
:
pay（）{
intdays;
cout<<"请输入请假天数:
\n";
cin>>days;
base_salary=Grades[grade]*（23-days）/23;
career_salary=base_salary/2;//普通员工业绩工资为基本工资的一半
salary=base_salary+career_salary;
}
classmanager:
virtualpublicemployee{//虚基类
protected:
doubleprize;//固定奖金额
doublefactor;//业绩系数
public:
manager（string="",int=0,int=0,double=0）;
voidpay（）;
};
manager:
:
manager（stringnn,intid,intgr,doublepr）:
employee（nn,id,gr）{
prize=pr;//固定奖金额
factor=0;
}
voidmanager:
:
pay（）{
intdays;
cout<<"请输入请假天数:
\n";
cin>>days;
cout<<"请输入业绩系数:
\n";
cin>>factor;
base_salary=Grades[grade]*（23-days）/23;
career_salary=prize*factor*（23-days）/23;
salary=base_salary+career_salary;
}
classtechnician:
virtualpublicemployee{
protected:
doublehours;//月工作时数
doubleperhour;//每小时附加酬金
doubleshfactor;//研究进度系数
public:
technician（string="",int=0,int=0,double=0）;
voidpay（）;
};
technician:
:
technician（stringnn,intid,intgr,doublephr）:
employee（nn,id,gr）{
hours=0;
perhour=phr;//每小时附加酬金
shfactor=0;
}
voidtechnician:
:
pay（）{
intdays;
cout<<"请输入请假天数:
\n";
cin>>days;
cout<<"请输入研究进度系数:
\n";
cin>>shfactor;
hours=8*（23-days）;
base_salary=Grades[grade]*（23-days）/23;
career_salary=perhour*hours*shfactor*（23-days）/23;
salary=base_salary+career_salary;
}
classsalesman:
virtualp
升级会员 