C++课堂练习2文档格式.docx

C++课堂练习2文档格式.docx

《C++课堂练习2文档格式.docx》由会员分享，可在线阅读，更多相关《C++课堂练习2文档格式.docx（40页珍藏版）》请在冰豆网上搜索。

{

cout<

x<

y<

z<

Bb;

b.x=3;

b.y=3;

b.z=3;

//私有继承

privateA

//保护继承

protectedA

classC:

protectedB

{}

//类型兼容规则

b.x=2;

//Aa=b;

//A&

a=b;

A*p=&

b;

p->

y;

1分析以下程序的执行结果

#include<

iostream.h>

classbase

{intn;

base（inta）

{

constructingbaseclass"

n=a;

n="

n<

}

~base（）

{cout<

destructingbaseclass"

}

classsubs:

publicbase

{

basebobj;

intm;

subs（inta,intb,intc）:

bobj（c）,base（a）

constructingsubcass"

m=b;

m="

m<

~subs（）

destructingsubclass"

voidmain（）

{subss（1,2,3）;

本题说明派生类中含有对象成员情况下构造函数和析构函数的调用顺序。

这里base为基类,subs为派生类，subs类的构造函数中含有对象成员。

所以输出为：

constrcutingbaseclass

n=1

constructingbaseclass

n=3

constructingsubclass

m=2

destructingsubclass

destructingbaseclass

注意：

当派生类中含有对象成员时，构造函数的调用顺序如下：

1）基类的构造函数2）对象成员的构造函数3）派生类的构造函数4析构函数的调用顺序与之反

2设计一个圆类circle和一个桌子类table，另设计一个圆桌类roundtable，它是从前两个类派生的，要求输出一个圆桌的高度、桌面面积和颜色等数据。

分析：

circle类包含私有数据成员radius和求圆面积的成员函数getarea（）；

table类包含私有数据成员height和返回高度的成员函数getheight（）。

roundtable类继承所有上述类的数据成员和成员函数，添加了私有数据成员color和相应的成员函数。

string.h>

classcircle

doubleradius;

circle（doubler）{radius=r;

doublegetarea（）{returnradius*radius*3.14;

classtable

doubleheight;

table（doubleh）{height=h;

doublegetheight（）{returnheight;

classroundtable:

publictable,publiccircle

char*color;

roundtable（doubleh,doubler,charc[]）:

circle（r）,table（h）

color=newchar[strlen（c）+1];

strcpy（color,c）;

char*getcolor（）{returncolor;

roundtablert（0.8,1.2,"

黑色"

）;

cout<

"

圆桌属性数据:

<

endl;

高度：

rt.getheight（）<

米"

面积：

rt.getarea（）<

平方米"

颜色：

rt.getcolor（）<

3图书馆的图书包含书名、编号、作者属性，读者包含姓名和借书证属性，每位读者最多可借5本书，编写程序输出某读者的借书情况。

设计一个类object，从它派生出书类book和读者类reader，在reader类中有一个rentbook（）成员函数用于借阅图书。

classobject

charname[20];

intno;

object（）{}

object（charna[],intn）

strcpy（name,na）;

no=n;

voidshow（）

name<

（"

no<

）"

;

classbook:

publicobject

charauthor[10];

book（）{}

book（charna[],intn,charauth[]）:

object（na,n）

{strcpy（author,auth）;

}

voidshowbook（）

show（）;

作者：

author;

classreader:

bookrent[5];

intk;

reader（charna[],intn）:

object（na,n）{k=0;

voidrentbook（book&

b）

rent[k]=b;

k++;

voidshowreader（）

读者：

show（）;

endl<

所借图书:

for（inti=0;

i<

k;

i++）

{

cout<

i+1<

:

//5个空格

rent[i].show（）;

bookb1（"

C语言"

100,"

谭浩强"

）,b2（"

数据结构"

110,"

严蔚敏"

readerr1（"

王华"

1234）;

r1.rentbook（b1）;

r1.rentbook（b2）;

r1.showreader（）;

4分析以下程序的执行结果

classA

intn;

virtualpublicA{};

//对比不加virtual的情况

classD:

publicB,publicC

intgetn（）{returnB:

n;

Dd;

d.B:

n=10;

d.C:

n=20;

d.B:

"

d.C:

D类是从B类和C类派生的而B类和C类又都是从A类派生，但这是虚继承关系即是虚基类，因此共用一个的副本，所以对于对象d，d.B:

n与d.C:

n是一个成员。

20，20

5设计一个虚基类base，包含姓名和年龄私有数据成员以及相关的成员函数，由它派生出领导类leader，包含职务和部门私有数据成员以及相关的成员函数。

再由base派生出工程师类engineer，包含职称和专业私有数据成员以及相关的成员函数。

然后由leader和engineer类派生出主任工程师类chairman。

采用一些数据进行测试。

由于chairman类从leader类和engineer类派生，而leader类和engineer类都是从base类派生的，所以为了使base只存一个副本，必须采用虚拟派生的方法。

//7_8.cpp

classB0//声明基类B0

//外部接口

intnV;

voidfun（）{cout<

MemberofB0"

classB1:

virtualpublicB0//B0为虚基类，派生B1类

//新增外部接口

intnV1;

classB2:

virtualpublicB0//B0为虚基类派生B2类

intnV2;

classD1:

publicB1,publicB2//派生类D1声明

intnVd;

voidfund（）{cout<

MemberofD1"

voidmain（）//程序主函数

D1d1;

//声明D1类对象d1

d1.nV=1;

//使用直接基类

d1.nV1=2;

d1.nV2=3;

d1.nVd=4;

sizeof（d1）<

d1+0）<

d1+1）<

d1+2）<

d1+3）<

d1+4）<

d1+5）<

classbase//基类

char*name;

//姓名

intage;

//年龄

base（）{}

voidsetname（charna[]）

name=newchar[strlen（na）+1];

voidsetage（inta）

age=a;

char*getname（）{returnname;

intgetage（）{returnage;

classleader:

virtualpublicbase//领导类

char*job;

//职务

char*dep;

//部门

leader（）{}

voidsetjob（charjb[]）

job=newchar[strlen（jb）+1];

strcpy（job,jb）;

voidsetdep（chardp[]）

dep=newchar[strlen（dp）+1];

strcpy（dep,dp）;

char*getjob（）{returnjob;

char*getdep（）{returndep;

classengineer:

virtualpublicbase//工程师类

char*major;

//专业

char*prof;

//职称

engineer（）{}

voidsetmajor（charmaj[]）

major=newchar[strlen（maj）+1];

strcpy（major,maj）;

voidsetprof（charpf[]）

prof=newchar[strlen（pf）+1];

strcpy（prof,pf）;

char*getmajor（）{returnmajor;

char*getprof（）{returnprof;

};

classchairman:

publicleader,publicengineer//主任工程师类

{};

chairmanc;

c.setname（"

李明"

c.setage（42）;

c.setjob（"

处长"

c.setdep（"

设计处"

c.setmajor（"

电站锅炉设计"

c.setprof（"

高级工程师"

输出结果：

c.getname（）<

，年龄"

c.getage（）<

岁，担任"

c.getdep（）<

c.getjob（）<

，"

c.getprof（）<

，从事"

c.getmajor（）<

专业"

。

或改成带参数的构造函数：

base（charna[],inta）

delete[]name;

leader（charna[],inta,charjb[],chardp[]）:

base（na,a）

~leader（）

delete[]job;

delete[]dep;

engineer（charna[],inta,charmaj[],charpf[]）:

base（na,a）

~engineer（）

delete[]major;

delete[]prof;

chairman（charna[],inta,charjb[],chardp[],charmaj[],charpf[]）:

base（na,a）,leader（na,a,jb,dp）,engineer（na,a,maj,pf）

{}

chairmanc（"

42,"

6分析以下程序的执行结果

classSample

Sample（）{}

Sample（inti）{n=i;

Sample&

operator=（Sample）;

voiddisp（）{cout<

Sample&

Sample:

operator=（Samples）

Sample:

n=s.n;

return*this;

Samples1（10）,s2;

s2=s1;

s2.disp（）;

本题说明重载运算符（=）的使用方法。

operator=成员函数实现两个对象的赋值。

n=10

7分析以下程序的执行结果

operator++（）{n++;

operator++（int）{n+=2;

voiddisp（）

SampleA

（2）,B

（2）;

A++;

++B;

A.disp（）;

B.disp（）;

本题说明重载运算符++的使用方法。

operator++（）为前缀重载运算符，operator++（int）为后缀重载运算符。

A++的语句调用后缀重载运算符，++B语句调用前缀重载运算符。

n=4

8分析以下程序的执行结果

intA[10][10];

int&

operator（）（int,int）;

int&

operator（）（intx,inty）

returnA[x][y];