C++实验三继承和派生类附答案.docx

C++实验三继承和派生类附答案.docx

《C++实验三继承和派生类附答案.docx》由会员分享，可在线阅读，更多相关《C++实验三继承和派生类附答案.docx（28页珍藏版）》请在冰点文库上搜索。

C++实验三继承和派生类附答案

实验三继承和派生类

实验目的和要求

1．理解类的继承的概念，能够定义和使用类的继承关系。

2．掌握派生类的声明与定义方法。

3．熟悉公有派生和私有派生的访问特性。

4．学习虚基类在解决二义性问题中的作用。

实验内容

1.先阅读下面的程序，分析程序运行的结果，然后再上机运行程序，验证自己分析的结果是否正确。

（1）

#include

classA

{

public:

A（）

{

cout<<"A:

:

A（）called.\n";

}

~A（）

{

cout<<"A:

:

~A（）called.\n";

}

};

classB:

publicA

{

public:

B（inti）

{

cout<<"B:

:

B（）called.\n";

buf=newchar[i];

}

~B（）

{

delete[]buf;

cout<<"B:

~B（）called.\n";

}

private:

char*buf;

};

voidmain（）

{

Bb（10）;

}

（2）

#include

classA

{

public:

A（inta,intb）:

x（a）,y（b）

{

cout<<"Aconstructor..."<

}

voidAdd（inta,intb）

{

x+=a;

y+=b;

}

voiddisplay（）

{

cout<<"（"<

}

~A（）

{

cout<<"destructorA..."<

}

private:

intx,y;

};

classB:

privateA

{

private:

inti,j;

AAobj;

public:

B（inta,intb,intc,intd）:

A（a,b）,i（c）,j（d）,Aobj（1,1）

{

cout<<"Bconstructor..."<

}

voidAdd（intx1,inty1,intx2,inty2）

{

A:

:

Add（x1,y1）;

i+=x2;

j+=y2;

}

voiddisplay（）

{

A:

:

display（）;

Aobj.display（）;

cout<<"（"<

}

~B（）

{

cout<<"destructorB..."<

}

};

voidmain（）

{

Bb（1,2,3,4）;

b.display（）;

b.Add（1,3,5,7）;

b.display（）;

}

（3）

#include

classA

{

public:

A（inta）:

x（a）

{

cout<<"Aconstructor..."<

}

intf（）

{

return++x;

}

~A（）

{

cout<<"destructorA..."<

}

private:

intx;

};

classB:

publicvirtualA

{

private:

inty;

AAobj;

public:

B（inta,intb,intc）:

A（a）,y（c）,Aobj（c）

{

cout<<"Bconstructor..."<

}

intf（）

{

A:

:

f（）;

Aobj.f（）;

return++y;

}

voiddisplay（）

{

cout<

:

f（）<<'\t'<

}

~B（）

{

cout<<"destructorB..."<

}

};

classC:

publicB

{

public:

C（inta,intb,intc）:

B（a,b,c）,A（0）

{

cout<<"Cconstructor..."<

}

};

classD:

publicC,virtualpublicA

{

public:

D（inta,intb,intc）:

C（a,b,c）,A（c）

{

cout<<"Dconstructor..."<

}

~D（）

{

cout<<"destructorD..."<

}

};

voidmain（）

{

Dd（7,8,9）;

d.f（）;

d.display（）;

}

（4）

#include

classBase1

{

public:

Base1（）

{

cout<<"classBase1!

"<

}

};

classBase2

{

public:

Base2（）

{

cout<<"classBase2!

"<

}

};

classLevel1:

publicBase2,virtualpublicBase1

{

public:

Level1（）

{

cout<<"classLevel1!

"<

}

};

classLevel2:

publicBase2,virtualpublicBase1

{

public:

Level2（）

{

cout<<"classLevel2!

"<

}

};

classTopLevel:

publicLevel1,virtualpublicLevel2

{

public:

TopLevel（）

{

cout<<"classTopLevel!

"<

}

};

voidmain（）

{

TopLevelobj;

}

2.调试下列程序，并对程序进行修改后再调试，指出调试中的出错原因。

#include

classA

{

public:

voidseta（inti）

{a=i;}

intgeta（）

{returna;}

public:

inta;

};

classB:

publicA

{

public:

voidsetb（inti）

{b=i;}

intgetb（）

{returnb;}

voidshow（）

{cout<<"A:

:

a="<

public:

intb;

};

voidmain（）

{

Bbb;//语句1

bb.seta（6）;//语句2

bb.setb（3）;//语句3

bb.show（）;//语句4

cout<<"A:

:

a="<

cout<<"B:

:

b="<

cout<<"A:

:

a="<

cout<<"B:

:

b="<

}

按下列要求对程序进行修改，然后调试，对出现的错误分析其原因。

（1）将派生类B的继承方式改为private时，会出现哪些错误和不正常现象？

为什么？

（2）将派生类B的继承方式改为protected时，会出现哪些错误和不正常现象？

为什么？

（3）将派生类B的继承方式恢复为public后，再将类A中数据成员a的访问权限改为private时，会出现哪些错误和不正常现象？

为什么？

（4）派生类B的继承方式仍为public，将类A中数据成员a的访问权限改为protected时，会出现哪些错误和不正常现象？

为什么？

3.定义一个类MyArray，类中可以存放一组整数。

类的定义如下：

classMyArray

{

public:

MyArray（intlen）;//初始化，动态申请存储空间

~MyArray（）;//对象结束时，释放所占用的存储空间

voidInput（）;//输入数据

voidDisplay（）;//显示数据

protected:

int*alist;//指向动态申请的一组空间

intlength;//整数的个数

};

基类中有构造函数、析构函数、输入数据和输出数据的函数。

（1）实现该类并设计主函数对所定义的类进行调试。

下同。

（2）由MyArray派生一个类SortArray，在该类中定义函数实现排序功能。

（3）由MyArray派生一个类ReArray，在该类中定义函数实现数据前后逆转功能。

（4）由MyArray派生一个类AverArray，在该类中定义函数Aver求解类中所有数据的平均值。

（5）定义NewArray类，同时继承了SortArray,ReArray和AverArray，使得NewArray类的对象同时具有排序、逆转和求平均值的功能。

在继承的过程中声明为虚基类，体会虚基类在解决二义性问题中的作用。

参考答案（非权威，仅仅是我自己的理解，如有错误，欢迎批评指正！

）

1.

（1）

1.

（2）

1.（3）

1.（4）

2.

（1）主函数中语句2、语句5、语句7出现错误。

因为B采用私有继承，所以A中的公有函数在B中是变为私有函数，主函数中不能访问B中的私有函数。

（2）主函数中语句2、语句5、语句7出现错误。

因为B采用保护继承，所以A中的公有函数在B中是变为保护函数，主函数中不能访问B中的保护函数。

（3）主函数中语句9、语句5出现错误。

因为B采用公有继承，所以B中和主函数中不能访问A中的私有函数。

（4）主函数中语句5出现错误。

因为B采用公有继承，所以A中保护成员在B中仍为保护成员，B中可以访问A中的保护成员，但不能通过类的对象访问类的保护成员。

3.

（1）

#include

classMyarray

{

protected:

int*alist;//指向动态申请的一组空间

intlength;//整数的个数

public:

Myarray（intlen）//初始化，动态申请存储空间

{

alist=newint[len];

length=len;

}

~Myarray（）//对象结束时，释放所占用的存储空间

{

delete（alist）;

cout<

"<

}

voidInput（）//输入数据

{

inti;

for（i=0;i

{

cout<<"输入数组的第"<

";

cin>>alist[i];

}

}

voidDisplay（）//显示数据

{

cout<<'\n'<<"数组的成员为：

"<<'\n';

for（inti=0;i

cout<

cout<

}

};

voidmain（）

{

MyarrayA（3）;

A.Input（）;

A.Display（）;

}

（2）

#include

classMyarray

{

protected:

int*alist;//指向动态申请的一组空间

intlength;//整数的个数

public:

Myarray（intlen）//初始化，动态申请存储空间

{

alist=newint[len];

length=len;

cout<<"Myarray初始化..."<

}

~Myarray（）//对象结束时，释放所占用的存储空间

{

delete（alist）;

cout<

"<

}

voidInput（）//输入数据

{

inti;

for（i=0;i

{

cout<<"输入数组的第"<

";

cin>>alist[i];

}

}

voidDisplay（）//显示数据

{

cout<<'\n'<<"本数组成员依次为：

"<<'\n';

for（inti=0;i

cout<

cout<

}

};

classSortArray:

virtualpublicMyarray

{

public:

SortArray（intn）:

Myarray（n）

{

cout<<"SortArray初始化..."<

}

voidsort（）

{

inti,j,k,temp;

for（i=0;i

{

k=i;

for（j=i+1;j

if（alist[j]

{

k=j;

}

temp=alist[i];

alist[i]=alist[k];

alist[k]=temp;

}

}

};

voidmain（）

{

SortArrayB（4）;

B.Input（）;

B.Display（）;

cout<

"<

B.sort（）;

B.Display（）;

}

（3）

#include

classMyarray

{

protected:

int*alist;//指向动态申请的一组空间

intlength;//整数的个数

public:

Myarray（intlen）//初始化，动态申请存储空间

{

alist=newint[len];

length=len;

cout<<"Myarray初始化..."<

}

~Myarray（）//对象结束时，释放所占用的存储空间

{

delete（alist）;

cout<

"<

}

voidInput（）//输入数据

{

inti;

for（i=0;i

{

cout<<"输入数组的第"<

";

cin>>alist[i];

}

}

voidDisplay（）//显示数据

{

cout<<'\n'<<"本数组成员依次为：

"<<'\n';

for（inti=0;i

cout<

cout<

}

};

classReArray:

virtualpublicMyarray

{

public:

ReArray（intn）:

Myarray（n）

{

cout<<"ReArray初始化..."<

}

voidturn（）

{

inti,t,j=length-1;

for（i=0;i

{

t=alist[i];

alist[i]=alist[j];

alist[j]=t;

}

}

};

voidmain（）

{

ReArrayB（4）;

B.Input（）;

B.Display（）;

cout<

"<

B.turn（）;

B.Display（）;

}

（4）

#include

classMyarray

{

protected:

int*alist;//指向动态申请的一组空间

intlength;//整数的个数

public:

Myarray（intlen）//初始化，动态申请存储空间

{

alist=newint[len];

length=len;

cout<<"Myarray初始化..."<

}

~Myarray（）//对象结束时，释放所占用的存储空间

{

delete（alist）;

cout<

"<

}

voidInput（）//输入数据

{

inti;

for（i=0;i

{

cout<<"输入数组的第"<

";

cin>>alist[i];

}

}

voidDisplay（）//显示数据

{

cout<<'\n'<<"本数组成员依次为：

"<<'\n';

for（inti=0;i

cout<

cout<

}

};

classAverArray:

virtualpublicMyarray

{

public:

AverArray（intn）:

Myarray（n）

{

cout<<"AverArray初始化..."<

}

floatgetaver（）

{

floataver;

intsum=0,i;

for（i=0;i

sum+=alist[i];

aver=（float）sum/length;

returnaver;

}

};

voidmain（）

{

AverArrayB（3）;

B.Input（）;

B.Display（）;

cout<

";

cout<

}

（5）

#include

classMyarray

{

protected:

int*alist;//指向动态申请的一组空间

intlength;//整数的个数

public:

Myarray（intlen）//初始化，动态申请存储空间

{

alist=newint[len];

length=len;

cout<<"Myarray初始化..."<

}

~Myarray（）//对象结束时，释放所占用的存储空间

{

delete（alist）;

cout<

"<

}

voidInput（）//输入数据

{

inti;

for（i=0;i

{

cout<<"输入数组的第"<

";

cin>>alist[i];

}

}

voidDisplay（）//显示数据

{

cout<

";

for（inti=0;i

cout<

cout<

}

};

classSortArray:

virtualpublicMyarray//从小到大排序

{

public:

SortArray（intn）:

Myarray（n）

{

cout<<"SortArray初始化..."<

}

voidget_SortArray（）

{

inti,j,k,temp;

for（i=0;i

{

k=i;

for（j=i+1;j

if（alist[j]

{

k=j;

}

temp=alist[i];

alist[i]=alist[k];

alist[k]=temp;

}

}

};

classReArray:

virtualpublicMyarray//前后逆转

{

public:

ReArray（intn）:

Myarray（n）

{

cout<<"ReArray初始化..."<

}

voidget_ReArray（）

{

inti,t,j=length-1;

for（i=0;i

{

t=alist[i];

alist[i]=alist[j];

alist[j]=t;

}

}

};

classAverArray:

virtualpublicMyarray//求平均值

{

public:

AverArray（intn）:

Myarray（n）

{

cout<<"AverArray初始化..."<

}

floatget_AverArray（）

{

floataver;

intsum=0,i;

for（i=0;i

sum+=alist[i];

aver=（float）sum/length;

returnaver;

}

};

classNewArray:

publicSortArray,publicReArray,publicAverArray

{

public:

NewArray（int