第章习题答案.docx

第章习题答案.docx

《第章习题答案.docx》由会员分享，可在线阅读，更多相关《第章习题答案.docx（21页珍藏版）》请在冰豆网上搜索。

第章习题答案

第七章派生与继承

1.单选题

（1）．下列关于继承的描述中，错误的是（B）。

A．继承是重用性的重要机制

B．C++语言支持单重继承和双重继承

C．继承关系不是可逆的

D．继承是面向对象程序设计语言的重要特性

（2）．下列关于基类和派生类的描述中，错误的是（C）。

A．一个基类可以生成多个派生类

B．基类中所有成员都是它的派生类的成员

C．基类中成员访问权限继承到派生类中不变

D．派生类中除了继承的基类成员还有自己的成员

（3）．下列关于派生类的描述中，错误的是（D）。

A．派生类至少有一个基类

B．一个派生类可以作另一个派生类的基类

C．派生类的构造函数中应包含直接基类的构造函数

D．派生类默认的继承方式是public

（4）．派生类的对象可以直接访问的基类成员是（A）。

A．公有继承的公有成员B．保护继承的公有成员

C．私有继承的公有成员D．公有继承的保护成员

（5）．下列描述中，错误的是（D）。

A．基类的protected成员在public派生类中仍然是protected成员

B．基类的private成员在public派生类中是不可访问的

C．基类public成员在private派生类中是private成员

D．基类public成员在protected派生类中仍是public成员

（6）．派生类构造函数的成员初始化列表中，不能包含的初始化项是（B）。

A．基类的构造函数B．基类的子对象

C．派生类的子对象D．派生类自身的数据成员

（7）．下列关于子类型的描述中，错误的是（B）。

A．在公有继承下，派生类是基类的子类型

B．如果类A是类B的子类型，则类B也是类A的子类型

C．如果类A是类B的子类型，则类A的对象就是类B的对象

D．在公有继承下，派生类对象可以初始化基类的对象引用

（8）．下列关于多继承二义性的描述中，错误的是（D）。

A．一个派生类的多个基类中出现了同名成员时，派生类对同名成员的访问可能出现二义性

B．一个派生类有多个基类，而这些基类又有一个共同的基类，派生类访问公共基类成员时，可能出现二义性

C．解决二义性的方法是采用类名限定

D．基类和派生类中同时出现同名成员时，会产生二义性

2．多重继承与单一继承的区别是什么？

答：

派生类只有一个基类的称为单一继承。

单一继承的定义格式为：

class<派生类名>：

<继承方式><基类名>

{

派生类中新成员定义

}

派生类有两个或两个以上的基类称为多重继承。

多重继承的定义格式为：

class<派生类名>：

<继承方式1><基类名1>，<继承方式2><基类名2>，……<继承方式n><基类名n>

{

派生类中新成员定义

}

3．继承有哪三种继承方式，各自有何特点？

答：

继承方式主要表示派生类继承基类时采用的继承方式，主要有三种，即公有继承、私有继承和保护继承。

（1）公有继承（public）。

公有继承的特点是基类的公有成员和保护成员作为派生类的成员时，它们都保持原有的状态，而基类的私有成员仍然是私有的。

（2）私有继承（private）

私有继承的特点是基类的公有成员和保护成员作为派生类的私有成员，并且不能被这个派生类的子类访问。

（3）保护继承（protected）

保护继承的特点是基类的所有公有成员和保护成员都成为派生类的保护成员，并且只能被它的派生类成员函数或友元访问，基类的私有成员仍然是私有的。

4.在定义派生类的过程中，如何对基类的数据成员进行初始化？

答：

由于基类在派生类中通常是隐藏的，所以依序通过调用基类的构造函数来设定基类的数据成员的初值。

它的格式为<派生类名>（形参表）：

基类1（参数表），基类2（参数表）…对象成员1（参数表），对象成员2（参数表）…{}

5.什么是赋值兼容规则？

赋值兼容规则的实质是什么？

试举例说明。

答：

赋值兼容规则是指，对于共有派生类来说，可以将派生类的对象赋值给其基类。

它实质上就是基类对象的内存空间和派生类对象中基类拷贝的内存空间引用的兼容。

6.什么是虚基类？

它的作用是什么？

答：

虚基类不是指基类是虚的，而是指在派生类中指定的基类是虚继承的方式。

使用虚基类的目的是在多重派生中使用共有基类在派生类中只有一个拷贝从而解决有多个基类拷贝所产生的二义性问题。

7.分析下列程序的运行结果。

#include

classA

{

private:

inta;

public:

A（inti=0）{a=i;}

voidshow（）{cout<<"a="<

};

classB

{

private:

intb;

public:

B（inti=0）{b=i;}

voidshow（）

{cout<<"b="<

};

classC:

publicA,publicB

{

private:

intc;

public:

C（inti=0,intj=0,intk=0）:

A（i）,B（j）

{c=k;}

voidshow（）

{

A:

:

show（）;

B:

:

show（）;

cout<<"c="<

}

};

voidmain（）

{

Bb（12）;

b.show（）;

Cc1,c2（30,40）,c3（70,80,90）;

c1.show（）;

c2.show（）;

c3.show（）;

c2.B:

:

show（）;

}

答：

程序运行结果：

b=12

a=0

b=0

c=0

a=30

b=40

c=0

a=70

b=80

c=90

b=40

分析：

（1）本程序是多重继承的程序，类C继承了类A和类B的数据成员。

（2）在主程序中，分别对类C的对象c1、c2、c3赋不同的值，则对类A和类B数据成员的赋值也不一样。

8.分析下列程序的运行结果。

#include

classBase1

{public:

Base1（inti）{cout<<"调用基类Base1的构造函数:

"<

};

classBase2

{public:

Base2（intj）{cout<<"调用基类Base2的构造函数:

"<

};

classA:

publicBase1,publicBase2

{public:

A（inta,intb,intc,intd）:

Base2（b）,Base1（c）,b2（a）,b1（d）

{cout<<"调用派生类A的构造函数:

"<

private:

Base1b1;

Base2b2;

};

intmain（）

{Aobj（1,2,3,4）;}

答：

调用基类BASE1的构造函数:

3

调用基类BASE2的构造函数:

2

调用基类BASE1的构造函数:

4

调用基类BASE2构造函数:

1

调用派生类A的构造函数:

10

9.分析下列程序的运行结果。

#include

classA

{public:

A（constchar*s）{cout<

~A（）{}

};

classB:

virtualpublicA

{public:

B（constchar*s1,constchar*s2）:

A（s1）

{cout<

};

classC:

virtualpublicA

{public:

C（constchar*s1,constchar*s2）:

A（s1）

{cout<

};

classD:

publicB,publicC

{public:

D（constchar*s1,constchar*s2,constchar*s3,constchar*s4）

:

B（s1,s2）,C（s1,s3）,A（s1）

{cout<

};

intmain（）

{D*ptr=newD（"classA","classB","classC","classD"）;

deleteptr;

}

答：

classA

classB

classC

classD

10.有人定义一个教师类派生一个学生类。

他认为“姓名”和“性别”是教师、学生共有的属性，声明为public，“职称”和“工资”是教师特有的，声明为private。

在学生类中定义特有的属性“班级”和“成绩”。

所以有

classteacher

{public:

charname[20];charsex;

//……

Private:

chartitle[20];doublesalary;

};

classstudent:

publicteacher

{//……

private:

chargrade[20];intscore;

};

你认为这样定义合适吗？

请做出你认为合理的类结构定义。

答：

不合适，这样导致数据冗余。

合理的结构是提取它们共有的数据和操作定义一个基类，然后分别定义teacher和student作为派生类。

classperson

{protected:

charname[20];charsex;

//……

};

classteacher:

publicteache

{//……

private:

chartitle[20];doublesalary;

};

classstudent:

publicteacher

{//……

private:

chargrade[20];intscore;

};

11.定义一个描述坐标位置的类location，从location派生出正方形类square，在正方形类中将location类作为正方形的起始点，并求正方形的周长和面积。

答：

#include

classlocation

{

protected:

intx,y;

public:

location（inta=0,intb=0）

{

x=a;

y=b;

}

};

classsquare:

publiclocation

{

private:

intlen;

intgirth;

intarea;

public:

square（intx,inty,intt）:

location（x,y）

{

len=t;

}

voidset（）;

voidshow（）;

};

voidsquare:

:

set（）

{

girth=4*len;

area=len*len;

}

voidsquare:

:

show（）

{

cout<<"正方形的坐标点为：

"<

cout<<"正方形的周长为：

"<

cout<<"正方形的面积为：

"<

}

voidmain（）

{

squarem（10,10,5）;

m.set（）;

m.show（）;

}

12.把定义平面直角坐标系上的一个点的类Point作为基类，派生出描述一条直线的类Line，再派生出一个矩形类Rect。

要求成员函数能求出两点间的距离，矩形的周长和面积等。

设计一个测试程序，并构造完整的程序。

答：

#include

#include

usingnamespacestd;

classPoint{

public:

Point（intx=0,inty=0）

{

this->x=x;

this->y=y;

}

public:

intx,y;

};

classLine:

publicPoint

{

public:

Line（intx1=0,inty1=0,intx2=0,inty2=0）

:

a（x1,y1）,b（x2,y2）

{}

doubleLength（）{

ints=a.x-b.x;

intt=a.y-b.y;

returnsqrt（s*s+t*t）;

}

private:

Pointa,b;

};

classRect:

publicLine{

public:

Rect（intx1,inty1,intx2,inty2）:

l1（x1,y1,x1,y2）,l2（x1,y1,x2,y1）//x1,y1是矩形左下角的坐标，x2,y2是矩形右上角的坐标

{

}

doubleSumLength（）{

//cout<<"矩形的周长是"<<<

return（l1.Length（）+l2.Length（））*2;

}

doublesquare（）{

//cout<<"矩形的周长是"<<<

returnl1.Length（）*l2.Length（）;

}

private:

Linel1,l2;

};

voidmain（）{

Lineline（0,0,10,0）;

cout<<"这条线段的长度为：

"<

Rectrect（0,0,10,10）;

cout<<"矩形的周长是"<

cout<<"矩形的周长是"<

}

13.假设某销售公司有销售经理和销售员工，月工资的计算办法是：

销售经理的固定月薪为8000元并提取销售额的5/1000作为工资；销售员工只提取销售额的5/1000作为工资。

编一程序，定义一个基类Employee，它包含三个数据成员number、name和salary，以及用于输入编号和姓名的构造函数。

由Employee类派生Salesman类，再由Salesman类派生Salesmanager类。

Salesman类包含两个新数据成员commrate和sales，还包含用于输入销售额并计算销售员工工资的成员函数pay和用于输出的成员函数print。

Salesmanager类包含新数据成员monthlypay，以及用于输入销售额并计算销售经理工资的成员函数pay、用于输出的成员函数print（）。

在main函数中，测试你的类结构，求若干个不同员工的工资。

答：

#include

usingnamespacestd;

classemployee

{public:

employee（）

{cout<<"编号：

";cin>>number;

cout<<"姓名：

";cin>>name;

salary=0;

}

protected:

charnumber[5];

charname[10];

doublesalary;};

classsalesman:

publicemployee

{public:

salesman（）{commrate=0.005;}

voidpay（）

{cout<

";

cin>>sales;

salary=sales*commrate;

}

voidprint（）

{cout<<"销售员：

"<

"<

"<

protected:

doublecommrate;

doublesales;

};

classsalesmanager:

publicsalesman

{public:

salesmanager（）

{monthlypay=8000;

commrate=0.005;

}

voidpay（）

{cout<

";

cin>>sales;

salary=monthlypay+sales*commrate;

}

voidprint（）

{cout<<"销售经理：

"<

"<

"<

private:

doublemonthlypay;

};

intmain（）

{salesmanobj1;

obj1.pay（）;

obj1.print（）;

salesmanagerobj2;

obj2.pay（）;

obj2.print（）;

}

14.编写一个程序实现那一个班级学生的学期成绩管理。

个人信息类Person的数据成员有：

姓名，年龄，性别；课程类Course的数据成员有：

课程名，学分，成绩；

学生类Student从Person类派生，并增加数据成员：

学号，Course对象数据成员数组（大小为8），总成绩，总学分和平均成绩；

班级类Class类的数据成员有：

Student类对象成员数组（大小由构造函数确定），班号，班级人数等。

要求：

（1）本班级Class类的对象成员数组需要在构造函数中用new动态分配内存空间，在析构函数中释放。

在类Class中添加成员函数Seek，通过学号查找并输出该学生的全部信息。

（2）构造三个学生的数据，每个学生都有三门课程的成绩，输入并显示这些数据。

（3）根据类的需要添加适当的其他成员，编写完整的程序并测试。

答：

#include

#include

classPerson{

public:

Person（char*name,intage,charsex='M'）

{

strncpy（this->name,name,20）;

this->age=age;

this->sex=sex;

}

voidshow（）{

cout<<"学生的名字是：

"<

cout<<"学生的年龄是：

"<

cout<<"学生的性别是：

"<

}

private:

charname[20];

intage;

charsex;

};

classCourse{

public:

Course（）{

cout<<"请输入课程名，学分和分数"<

cin>>coursename>>credit>>score;

}

public:

charcoursename[20];

floatscore;

floatcredit;

};

classStudent:

Person{

public:

Student（char*name="NULL",intage=0,charsex='M',char*no="0"）:

Person（name,age,sex）,Course（）

{

strncpy（this->no,no,20）;

}

doubleMscoresum（）

{

scoresum=0;

for（inti=0;i<2;i++）

scoresum+=Cour[i].score;

returnscoresum;

}

doubleMcreditsum（）

{

creditsum=0;

for（inti=0;i<2;i++）

creditsum+=Cour[i].credit;

returncreditsum;

}

voidShow（）{

Person:

:

show（）;

cout<<"学号为：

"<

cout<<"总的学分为：

"<

cout<<"总的成绩为：

"<

}

public:

charno[20];

CourseCour[2];

floatscoresum;

floatcreditsum;

};

classClass{

private:

Student*stu;

charclassno[20];

intn;//班级人数

public:

Class（intn,char*classno）

{

this->n=n;

strncpy（this->classno,classno,20）;

stu=（Student*）newStudent[n];

}

~Class（）

{

if（stu）delete[]stu;

stu=NULL;

}

voidSeek（char*no）

{

for（inti=0;i

if（no==stu[i].no）

stu[i].Show（）;

break;

}

if（i==8）

cout<<"找不到该学生"<

}

voidShow（）{

cout<<"班级的学号为"<

";

for（inti=0;i

stu[0].Show（）;

}

};

voidmain（）{

Classcla（5,"1"）;

cla.Show（）;

//Studentstu（"Wang",16,'F',"4"）;

//stu.Show（）;

}