C语言第四章习题答案Word格式文档下载.docx

C语言第四章习题答案Word格式文档下载.docx

《C语言第四章习题答案Word格式文档下载.docx》由会员分享，可在线阅读，更多相关《C语言第四章习题答案Word格式文档下载.docx（25页珍藏版）》请在冰豆网上搜索。

Bb;

b.disp（）;

输出为：

classB

3下面程序的执行结果是（）

{public:

A（intI,intj）

{a=I;

b=j;

voidmove（intx,inty）

{a+=x;

b+=y;

voidshow（）

（"

a<

"

b<

）"

private:

inta,b;

privateA

{public:

B（intI,intj,intk,intl）:

A（I,j）

{x=k;

y=l;

x<

y<

voidfun（）

{move（2,4）;

voidf1（）

{A:

:

show（）;

intx,y;

{Ae（2,3）;

e.show（）;

Bd（4,5,6,7）;

d.fun（）;

d.show（）;

d.f1（）;

}

（2,3）

6,7

（6,9）

4下面程序的输出结果为

classbase

base（intx,inty）

{a=x;

b=y;

{cout<

base:

;

classderived:

publicbase

derived（intx,inty,intz）:

base（x,y）,c（z）

{}

derived:

c<

intc;

intmain（）

baseb（10,10）,*pb;

derivedd（20,30,40）;

pb=&

b;

pb->

d;

return0;

输出结果为

10;

10

20;

305

5、下面程序的输出结果为

classAA

protected:

intk;

AA（intn=4）:

k（n）

{}

~AA（）

AA"

virtualvoidf（）const=0;

inlinevoidAA:

f（）const

classBB:

publicAA

~BB（）

BB"

voidf（）const

k-2;

AA:

f（）;

AA&

p=*newBB;

p.f（）;

delete&

p;

}程式的执行结果2AA

6分析以下程式的执行结果：

classbase

{intn;

base（）{};

base（inta）

{

cout<

"

constructingbaseclass"

n=a;

n="

n<

}

~base（）{cout<

destructingbaseclass"

classsubs:

publicbase

{

intm;

subs（inta,intb）:

base（a）

constructingsubclass"

m=b;

m="

m<

subs（）{cout<

destructingsubclass"

voidmain（）

subss（1,2）;

解：

这里base是基类，subs为派生类，subs类的构造函数中含有调用基本类的构造函数。

所以输出为：

constructingbaseclass

n=1

constructingsubclass

n=2

destructingbaseclass

destructingsubclass

7分析以下程式的执行结果:

#include<

classA

inta;

A（inti）{a=i;

constructingclassA"

voidprint（）{cout<

a="

~A（）{cout<

destructingclassA"

classB1:

publicA

intb1;

B1（inti,intj）:

A（i）

{b1=j;

constructingclassB1"

voidprint（）

{A:

print（）;

b1="

b1<

~B1（）{cout<

destructingclassB1"

classB2:

intb2;

B2（inti,intj）:

{b2=j;

constructingclassB2"

}

b2="

b2<

~B2（）{cout<

destructingclassB2"

classC:

publicB1,publicB2

C（inti,intj,intk,intl,intm）:

B1（i,j）,B2（k,l）,c（m）

{cout<

constructingclassC"

{B1:

print（）;

B2:

c="

c<

~C（）{cout<

destructingclassC"

voidmain（）

Cc1（1,2,3,4,5）;

c1.print（）;

C类是从B1类和B2类派生的，而B1和B2类又都是从A类派生，但各有自己的副本，任何这些成员函数均有print（）成员函数。

所以，在C的成员函数实现中，调用print（）时，要加上类作用域运算符“：

：

”。

constructingclassA

constructingclassB1

constructingclassB2

constructingclassC

a=1

b1=2

a=3

b2=4

c=5

destructingclassC

destructingclassB2

destructingclassA

destructingclassB1

destructingclassA

8分析以下程式执行结果：

A（char*s）{cout<

s<

~A（）{}

B（char*sl,char*s2）:

A（sl）

s2<

C（char*sl,char*s2）:

classD:

publicB,publicC

D（char*sl,char*s2,char*s3,char*s4）:

B（sl,s2）,C（sl,s3）

s4<

Dd（"

classC"

classD"

）;

D类是从B和C类派生的，而B和C类又都是从A类派生，但各有自己的副本。

classB

classC

classD

9、分析以下程式的执行结果

base（）{cout<

~base（）{cout<

classsubs:

publicbase

subs（）{cout<

~subs（）{cout<

subss;

本题说明单继承情况下构造函数和析构函数的调用顺序。

这里base为基类，subs为派生类。

destructingsubclass

destrcutingbaseclass

注意：

在单继承情况下，首先调用基类的构造函数，随后调用派生类的构造函数，析构函数的调用顺序则正好相反。

10、分析以下程式的执行结果：

intn;

base（inta）

cout<

n<

basebobj;

subs（inta,intb,intc）:

base（a）,bobj（c）

{cout<

constructingsubcass"

cout<

m<

}

{subss（1,2,3）;

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

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

所以输出为：

constrcutingbaseclass

n=3

m=2

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

1）基类的构造函数

2）对象成员的构造函数

3）派生类的构造函数

析构函数的调用顺序和之相反

11、分析以下程式的执行结果

publicA{};

intgetn（）{returnB:

n;

Dd;

d.B:

n=10;

d.C:

n=20;

d.B:

d.C:

D类是从类和类派生的而类和类又都是从类派生的，但各有自己的副本。

所以对于对象d，d.B:

n和d.C:

n是两个不同的数据成员他们互无联系。

10，20

12、分析以下程式的执行结果

virtualpublicA{};

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

n是个成员。

20，20

13、编写一个程式设计一个汽车类vehicle，包含的数据成员有车轮个数wheels和车重weight。

小车类car是他的公有派生类其中包含载人数passenger_load。

卡车类truck是vehicle的公有派生类其中包含载人数passenger_load和载重量payload，每个类都有相关数据的输出方法。

vehicle类是基类由他派生出car类和truck类将公共的属性和方法放在vehicle类中。

本题程式如下：

classvehicle//定义汽车类

intwheels;

//车轮数

floatweight;

//重量

vehicle（intwheels,floatweight）;

intget_wheels（）;

floatget_weight（）;

floatwheel_load（）;

voidshow（）;

classcar:

publicvehicle//定义小车类

intpassenger_load;

//载人数

car（intwheels,floatweight,intpassengers=4）;

intget_passengers（）;

classtruck:

publicvehicle//定义卡车类

floatpayload;

//载重量

truck（intwheels,floatweight,intpassengers=2,floatmax_load=24000.00）;

floatefficiency（）;

vehicle:

vehicle（intwheels,floatweight）

{vehicle:

wheels=wheels;

vehicle:

weight=weight;

intvehicle:

get_wheels（）

{returnwheels;

floatvehicle:

get_weight（）

{returnweight/wheels;

voidvehicle:

show（）

{cout<

车轮:

wheels<

个"

重量:

weight<

公斤"

car:

car（intwheels,floatweight,intpassengers）:

vehicle（wheels,weight）

{passenger_load=passengers;

intcar:

get_passengers（）

{returnpassenger_load;

voidcar:

车型:

小车"

载人:

passenger_load<

人"

truck:

truck（intwheels,floatweight,intpassengers,floatmax_load）:

vehicle（wheels,weight）

payload=max_load;

inttruck:

get_passengers（）

floattruck:

efficiency（）

{returnpayload/（payload+weight）;

voidtruck:

车型:

卡车"

show（）;

效率:

efficiency（）<

{carcar1（4,2000,5）;

trucktru1（10,8000,3,340000）;

输出结果"

car1.show（）;

tru1.show（）;

解法2：

输出结果

车型：

小车

车轮：

4个

重量：

2000公斤

载人：

5人

卡车

10个

8000公斤

3人

效率：

0．977012

14、设计一个圆类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,"

黑色"

圆桌属性数据: