面向对象程序设计离线作业浙大2017

浙江大学远程教育学院

《面向对象程序设计》课程作业

姓名：何存宇学号:717015012001

年级：17计算机科学与技术学习中心：乐清学习中心

第2章

[2.3]测试下面的注释(它在C++风格的单行注释中套入了类似于C的注释)是

否有效。

//thisisastrange/*waytodoacomment*/

在单行中是有效的。主要因为〃单行注释起作用。

[2.4]以下这个简短的C++程序不可能编译通过，为什么？

#include<iostream>

usingnamespacestd;

intmain()

{inta,b,c;

cout«uEntertwonumbers:";

cin»a»b;

c=sum(a,b);

cout«nsumis:M«c;

return0;

)

sum(inta,intb)

{returna+b;

sum(inta,intb)函数没有声明返回值。

[2.5]回答问题。

(1)以下两个函数原型是否等价：

floatfun(inta,floatb,char*c);

floatfun(int,float,char*);

函数原型等价

(2)以下两个函数的第一行是否等价:

floatfun(inta,floatb,char*c);

floatfun(int,float,char*);

函数第一行不等价

[2.6]下列语句中错误的是(D)。

A,int*p=newint(l0)；B.int*p=newint[10]；

C.int*p=newint；D.int*p=newint[40](0)；

[2.7]假设已经有定义"constchar*constname="chen";”下面的语句中

正确的是(D)。

A.name[3]=H;B.name=Hlinn;

C.name=newchar[5];D.cout«name[3];

[2.8]假设已经有定义“char*constname="chen";”下面的语句中正确的

是(A)o

A.name[3]='q';B.name="lin”；

C.name=newchar[5];D.name=newchar('q');

[2.9]假设已经有定义"constchar*name="chen";”下面的语句中错误的

是(A)0

A.name[3]='q';B.name="linn;

C.name=newchar[5];D.name=newchar('q');

[2.10]重载函数在调用时选择的依据中，(B)是错误的。

A.函数名字B.函数的返回类型

C.参数个数D.参数的类型

[2.11]在(A)情况下适宜采用内联函数。

A.函数代码小，频繁调用B.函数代码多，频繁调用

C.函数体含有递归语句D.函数体含有循环语句

[2.12]下列描述中，（C）是错误的。

A.内联函数主要解决程序的运行效率问题

B.内联函数的定义必须出现在内联函数第一次被调用之前

C.内联函数中可以包括各种语句

D.对内联函数不可以进行异常接口声明

[2.13]在C++中，关于下列设置默认参数值的描述中，（B）是正确的。

A.不允许设置默认参数值

B.在指定了默认值的参数右边，不能出现没有指定默认值的参数

C.只能在函数的定义性声明中指定参数的默认值

D.设置默认参数值时，必须全部都设置

[2.14]下面的类型声明中正确是（D）。

A.int&a[4]；B.int&*p；

C.int&&q；D.inti,*p=&i；

[2.15]下面有关重载函数的说法中正确的是（C）»

A.重载函数必须具有不同的返回值类型

B.重载函数形参个数必须不同

C.重载函数必须有不同的形参列表

D.重载函数名可以不同

[2.16]关于new运算符的下列描述中，（D）是错误的。

A,它可以用来动态创建对象和对象数组

B.使用它创建的对象或对象数组可以使用运算符delete删除

C.使用它创建对象时要调用构造函数

D.使用它创建对象数组时必须指定初始值

[2.17]关于delete运算符的下列描述中，（C）是错误的。

A.它必须用于new返回的指针

B.使用它删除对象时要调用析构函数

C.对一个指针可以使用多次该运算符

D.指针名前只有一对方括号符号，不管所删除数组的维数

[2.18]写出下列程序的运行结果。

#include<iostream>

usingnamespacestd;

inti=15;

intmain()

{inti;

i=100;

::i=i+l;

cout«::i«endl;

return0;

)

运行结果：101

[2.19]写出下列程序的运行结果。

#include<iostream>

usingnamespacestd;

voidf(int&m,intn)

{inttemp;

temp=m;

m=n;

n=temp;

)

intmain()

{inta=5,b=10;

f(a,b);

cout«a«nn«b«endl;

return0;

运行结果：1010

[2.20]分析下面程序的输出结果。

#include<iostream>

usingnamespacestd;

int&f(int&i)

{i+=10;

returni;

)

intmain()

{intk=0;

int&m=f(k);

cout«k«endl;

m=20;

cout«k«endl;

return0;

)

运行结果：

10

20

[2.21]举例说明可以使用const替代祥define以消除祥define的不安全性。

例如：

#include<iostream.h>

#defineA1+2

#defineBA*4

voidmain(){cout«B«endl;}

上面程序的运行结果是9而不是12,但很容易被认为是12。如果用

const替代#define就能得到正确结果，从而消除了#define的不安全性。

#include<iostream.h>

constA=l+2;

constB=A*4;

voidmain(){cout«B«endl;}

运行结果为12o

[2.22]编写一个C++风格的程序，用动态分配空间的方法计算Fibonacci数

列的前20项，并存储到动态分配的空间中。

#include<iostream.h>

intmain()

(

int*p=newint[20];

*p=l;

*(p+l)=l；

cout«*p«"\t"«*(p+l)«"\t";

p=p+2;

for(inti=3;i<=20;i++)

(

*p=*(p-l)+*(p-2);

cout«*p«"\t";

if(i%5==0)cout«endl;

P++；

)

return0;

)

【2.23]编写一个C++风格的程序，建立一个被称为sroot()的函数，返回其参

数的二次方根。重载sroot()3次，让它返回整数、长整数与双精度数

的二次方根(计算二次方根时，可以使用标准库函数sqrt())。

#include<iostream.h>

#include<cmath>

doublesroot(inta)

{returnsqrt(a);

doublesroot(longb)

{returnsqrt(b);

doublesroot(doublec)

{returnsqrt(c);

)

intmain()

(

inti=67;

long1=6789;

doubled=67.89;

cout«ni的二次方根是:u«sroot(i)«endl;

cout«"l的二次方根是:“vvsroot⑴vvendl;

cout«"d的二次方根是:n«sroot(d)«endl;

return0;

)

[2.24]编写一个C++风格的程序，解决百钱问题：将一元人民币兑换成1、2、

5分的硬币，有多少种换法？

#include<iostream>

usingnamespacestd;

intmain()

(

inti,j,sum=0;

for(i=0;i<=20;i++)

for(j=0;j<=50;j++)

if(100-5*i-2*j>=0)

(

sum++;

cout«100-5*i-2*j«*,\t',«j«,,\t,,«i«endl;

cout«Hsumisn«sum«endl;

return0;

[2.25]编写一个C++风格的程序，输入两个整数，将它们按由小到大的顺序

输出。要求使用变量的引用。

#include<iostream>

usingnamespacestd;

voidchange(int&,int&);

intmain()

{

inta,b;

cin»a»b;

if(a>b)

change(a,b);

cout«a«"n«b«endl;

return0;

)

voidchange(int&n)

{inttemp;

temp=m;

m=n;

n=temp;

第三章：

[3.7]在下面有关对构造函数的描述中，正确的是（B）。

A.构造函数可以带有返回值

B.构造函数的名字与类名完全相同

C.构造函数必须带有参数

D.构造函数必须定义，不能默认

[3.8]在声明类时，下面的说法正确的是（C）。

A.可以在类的声明中给数据成员赋初值

B.数据成员的数据类型可以是register

C.private、public、protected可以按任意顺序出现

D.没有用private、public、protected定义的数据成员是公有成员

[3.9]在下面有关析构函数特征的描述中，正确的是（C）。

A.一个类中可以定义多个析构函数

B.析构函数名与类名完全相同

C.析构函数不能指定返回类型

D.析构函数可以有一个或多个参数

[3.10]构造函数是在（B）时被执行的。

A.程序编译B.创建对象

C.创建类D.程序装人内存

[3.11]在下面有关静态成员函数的描述中，正确的是（B）0

A.在静态成员函数中可以使用this指针

B.在建立对象前，就可以为静态数据成员赋值

C.静态成员函数在类外定义时，要用static前缀

D.静态成员函数只能在类外定义

[3.12]在下面有关友元函数的描述中，正确的说法是（A）o

A.友元函数是独立于当前类的外部函数

B.一个友元函数不能同时定义为两个类的友元函数

C.友元函数必须在类的外部定义

D.在外部定义友元函数时，必须加关键字friend

[3.13]友元的作用之一是(A)。

A.提高程序的运行效率B.加强类的封装性

C.实现数据的隐藏性D.增加成员函数的种类

[3,14]以下程序运行的结果是(B)o

#include<iostream>

usingnamespacestd;

classB{

public:

B(){}

B(inti,intj)

{x=i;

y=j；

}

voidprintb()

{cout«x«","«y«endl;

}

private:

intx,y;

)；

classA{

public:

A()

()

A(intI,intj);

voidprinta();

private:

Bc;

);

A::A(inti,intj):c(i,j)

()

voidA::printa()

{c.printb();

)

intmain()

{Aa(7,8)；

a.printaQ;

return0;

)

A.8,9B.7,8C.5,6D.9,10

[3,15]以下程序的运行结果是(A)o

#include<iostream>

usingnamespacestd;

classA{

public:

voidset(inti,intj)

{x=i;

y=j；

)

intget_y()

{returny;

)

private:

intx,y;

)；

classbox{

public:

voidset(intl,intw,ints,intp)

{length=l;

width=w;

label.set(s,p);

intget_area()

{returnlength*width;

private:

intlength,width;

Alabel;

);

intmain()

{boxb;

b.set(4,6,l,20);

cout«b.get_area()«endl;

return0;

)

A.24B.4C.20D.6

[3,16]以下程序的运行结果是(B)0

#include<iostream>

usingnamespacestd;

classSample(

public:

Sample(inti,intj)

{x=i;

y寸

)

voiddisp()

{cout«ndispl"«endl;

voiddisp()const

{cout«Hdisp2n«endl;

private:

intx,y;

)；

intmain()

{constSamplea(l,2);

a.dispO;

return0;

)

A.displB.disp2C.displdisp2D.程序编译出错

[3.17]以下程序的运行结果是(B)。

#include<iostream>

usingnamespacestd;

classR{

public:

R(intrl,intr2)

{Rl=rl;

R2=r2;

)

voidprint();

voidprint()const;

private:

intR1,R2;

);

voidR::print()

{cout«Rl«","«R2«endl;

)

voidR::print()const

{cout«Rl«n,"«R2«endl;

intmain()

{Ra(6,8);

constRb(56,88);

b.print();

return0;

)

A.6,8B.56,88C.0,0D.8,6

[3.18]写出下面程序的运行结果。

#include<iostream>

usingnamespacestd;

classtoy

{public:

toy(intq,intp)

{quan=q;

price=p;

)

intget_quan()

{returnquan;

)

intget_price()

{returnprice;

)

private:

intquan,price;

)；

intmain()

{toyop[3][2]={

toy(10,20),toy(30,48),

toy(50,68),toy(70,80),

toy(90,16),toy(l1,120),

);

for(inti=0;i<3;i++)

{cout«op[i][0].get_quan()«,,,n;

cout«op[i][0].get_price()«,,\nn;

cout«opfi]f1].get_quan()«'V，;

cout«op[i][1].get_price()«n\nK;

)

cout«endl;

return0;

)

运行结果：

10,20

30,48

50,68

70,80

90,16

11,120

[3.19]写出下面程序的运行结果。

#include<iostream>

usingnamespacestd;

classexample

{public:

example(intn)

{i=n;

cout«"Constructing\n";

)

~example()

{cout«"Destructing\n";

intget_i()

{returni;

private:

inti;

);

intsqr_it(exampleo)

{returno.get_i()*o.get_i();

)

intmain()

{examplex(10);

cout«x.get_i()«endl;

cout«sqr_it(x)«endl;

return0;

)

运行结果：

Constructing

10

Destructing

100

Destructing

[3.20]写出下面程序的运行结果。

#include<iostream>

usingnamespacestd;

classaClass

{public:

aClass()

{total++;

-aClassQ

{total—;

intgettotal()

{returntotal;

)

private:

staticinttotal;

);

intaClass::total=0;

intmain()

{aClassol,o2,o3;

cout«ol.gettotal()«nobjectsinexistence\n";

aClass*p;

p=newaClass;

if(!p)

{cout«nAllocationerror\n";

return1;

)

cout«ol.gettotal();

cout«nobjectsinexistenceafterallocation\nH;

deletep;

cout«ol.gettotal();

cout«nobjectsinexistenceafterdeletion\nn;

return0;

)

运行结果：

3objectsinexistence

4objectsinexistenceafterallocation

3objectsinexistenceafterdeletion

[3.21]写出下面程序的运行结果。

#include<iostream>

usingnamespacestd;

classtest

{public:

test();

~test(){};

private:

inti;

)；

test::test()

{i=25;

fbr(intctr=O;ctr<10;ctr++)

{cout«nCountingat^^«ctr«^^\n,^;

)

)

testanObject;

intmain()

{return0;

)

运行结果：

CountingatO

Countingatl

Countingat2

Countingat3

Countingat4

Countingat5

Countingat6

Countingat7

Countingat8

Countingat9

[3.22]写出下面程序的运行结果。

#include<iostream>

usingnamespacestd;

classA{

inta,b;

public:

A()

{a=0;

b=0;

cout«nDefaultconstructorcalled.\n";

)

A(inti,intj)

{a=i;

b=j；

cout«nConstructor:a="«a«,,,b="«b«endl;

)

);

intmainQ

{Aa[3];

Ab[3]={A(l,2),A(3,4),A(5,6)};

return0;

)

运行结果：

Defaultconstructorcalled.

Defaultconstructorcalled.

Defaultconstructorcalled.

Constructor:a=l,b=2

Constructor:a=3,b=4

Constructor:a=5,b=6

[3.23]写出下面程序的运行结果。

#include<iostream>

usingnamespacestd;

classTest{

private:

intval;

public:

Test()

{cout«ndefault.n«endl;

)

Test(intn)

{val=n;

cout«,,Con.,,«endl;

)

Test(constTest&t)

{val=t.val;

cout«"Copycon."«endl;

)

);

intmain()

{Testtl(6);

Testt2=tl;

Testt3;

t3=tl;

return0;

)

运行结果：

Con.

Copycon.

default.

[3.24]写出下面程序的运行结果。

#include<iostream>

usingnamespacestd;

classN{

private:

intA;

staticintB;

public:

N(inta)

{A=a;

B+=a;

)

staticvoidfl(Nm);

);

voidN::fl(Nm)

{cout«"A=n«m.A«endl;

cout«"B=n<<B«endl;

)

intN::B=0;

intmain()

{NP(5),Q(9);

N::fl(P);

N::fl(Q);

return0;

)

运行结果：

A=5

B=14

9=9

B=14

[3.25]写出下面程序的运行结果。

#include<iostream>

usingnamespacestd;

classM{

intx,y;

public:

M()

{x=y=O;

}

M(inti,intj)

{x=i;

y=j；

}

voidcopy(M*m);

voidsetxy(inti,intj)

{x=i;

y=j；

)

voidprint()

{cout«x«","«y«endl;

}

)；

voidM::copy(M*m)

{x=m->x;

y=m->y;

voidfun(Mml,M*m2)

{ml.setxy(12,15);

m2->setxy(22,25);

)

intmain()

{Mp(5,7),q;

q.copy(&p);

fun(p,&q);

pprint();

qprint();

return0;

)

运行结果：

5,7

22,25

[3.26]写出下面程序的运行结果。

#include<iostream>

usingnamespacestd;

classM{

intA;

staticintB;

public:

M(inta)

{A=a;

B+=a;

cout«"Constructing"«endl;

)

staticvoidfl(Mm);

-M()

{cout«"Destructing\n”;

voidm)

{cout«',A=,,«m.A«endl;

cout«nB="«B«endl;

}

intM::B=0;

intmain()

{Mp(5),Q(10);

M::fl(p);

M::fl(Q);

return0;

)

运行结果：

Constructing

Constructing

A=5

B=15

Destructing

A=10

B=15

Destructing

Destructing

Destructing

[3.27]指出下列程序中的错误，并说明为什么。

#include<iostream>

usingnamespacestd;

classStudent{

public:

voidprintStu();

private:

charname[10];

intage;

floataver;

);

intmain()

{Studentpl,p2,p3;

pl.age=30;

语句“pl.age=30;”编译出现错误,因为age是私有数据成员(private),不能被

直接访问。.

return0;

)

[3.28]指出下列程序中的错误，并说明为什么。

#include<iostream>

usingnamespacestd;

classStudent{

intsno;

intage;

voidprintStuQ;

voidsetSno(intd);

)；

voidprintStu();

{cout«H\nSnoisn«sno«n,n;

cout«nageis,,«age«,,.,,«endl;

voidsetSno(ints)

{sno=s;

voidsetAge(inta)

{age=a;

intmain()

{Studentlin;

lin.setSno(20021);

lin.setAge(20);

lin.printStu();

)

有三个错误：

第一，printStu。和setSno(intd)两个成员函数没有用public定义，在默认情况下

属于私有函数，不允许外部函数对对象进行操作；

第二，成员函数printStu。和setSno(intd)在类外定义，应加上类名uStudent：：”

第三，voidsetAge(inta)应在类中说明，并在类外定义，应加上类名“Student：：”

[3.29]指出下列程序中的错误，并说明为什么。

#include<iostream>

usingnamespacestd;

classPoint{

public:

intx,y;

private:

Piont()

{x=l;y=2;

)

)；

intmain()

{Pointcpoint;

cpoint.x=2;

return0;

有两个错误：

第一:构造函数名应与类名相同，"Piont。”应改为“Point。"；

第二，构造函数Point。是私有的，所以语句"Pointcpoint;”执行时出现错误,

原因是类Point构造函数私有，创建对象cpoint就不能调用它。

[3.30]下面是一个计算器类的定义，请完成该类成员函数的实现。

classcounter(

public:

counter(intnumber);

voidincrement();〃给原值加1

voiddecrement();〃给原值减1

intgetvalue();//取得计数器值

intprint();〃显示计数

private:

intvalue;

）；

程序如下

classcounter{

public:

counter(intnumber)；

voidincrement();

voiddecrement();

intgetvalue();

intprint();

rivate:

intvalue;

);

counter::counter(intnumber){value=number;}

voidcounter::increment(){value++;}

voidcounter::decrement(){value—;}

intcounter::getvalue(){returnvalue;}

intcounter::print(){

coutvv“valueisU«value«endl;

return0;

[3.31]根据注释语句的提示，实现类Date的成员函数。

#include<iostream>

usingnamespacestd;

classDate{

public:

voidprintDate();〃显示日期

voidsetDay(intd);〃设置日的值

voidsetMonth(intm);〃设置月的值

voidsetYear(inty);〃设置年的值

private:

intday,month,year;

);

intmain()

{DatetestDay;

testDay.setDay(5);

testDay.setMonth(10);

testDay.setYear(2003);

testDay.printDate();

return0;

代码如下：

voidDate::printDate()

cout«*'Dateis”v<dayv<"."；

cout«month«,,.',«year«endl;

)

voidDate::setDay(intd){day=d;}

voidDate::setMonth(intm){month=m;}

voidDate::setYear(inty){yeai-y;}

[3.32]建立类cylinder,cylinder的构造函数被传递了两个double值,分别

表示圆柱体的半径和高度。用类cylinder计算圆柱体的体积，并存储

在一个double变量中。在类cylinder中包含一个成员函数vol,用

来显示每个cylinder对象的体积。

#include<iostream.h>

classcylinder

(

public:

cylinder(doublea,doubleb);

voidvol();

private:

doubler,h;

doublevolume;

);

cylinder::cylinder(doublea,doubleb)

(

r=a;

h=b;

volume=3.141592*r*r*h;

)

voidcylinder::vol()

{cout«nvolumeis:"«volume«"\n";}

intmain()

cylinderx(4.5,6.88);

x.vol();

return0;

)

[3.33]构建一个类book,其中含有两个私有数据成员qu和price,将qu初

始化为1〜5,将price初始化为qu的10倍，建立一个有5个元素的

数组对象。显示每个对象数组元素的qu*price值。

#include<iostream>

usingnamespacestd;

classbook{

public:

book(inta,intb)

{qu=a;

price=b;}

voidshow_money()

{cout«qu*price«H\nn;}

private:

intqu,price;

)；

intmain()

(

bookob[5]={book(l,10),book(2,20),book(3,30),book(4,40),book(5,50)};

for(inti=0;i<5;i++)

ob[i].show_money();

return0;

[3.34]修改习题3.33,通过对象指针访问对象数组，使程序以相反的顺序显

示每个对象数组元素的qu*price值。

#include<iostream>

usingnamespacestd;

classbook{

public:

book(inta,intb)

{qu=a,price=b;}

voidshow_money()

{coutvvqu*price«”\n”;}

private:

intqu,price;

);

intmain()

(

bookob[5]={book(l,10),book(2,20),book(3,30),book(4,40),book(5,50)};

book*p;

p=&ob[4];

for(inti=0;i<5;i++)

(

p->show_money();

P-；

)

return0;

[3,35]构建一个类Stock,含字符数组stockcode□及整型数据成员quan、

双精度型数据成员price。构造函数含3个参数：字符数组na口及q、

P。当定义Stock的类对象时，将对象的第1个字符串参数赋给数据成

员stockcode,第2和第3个参数分别赋给quan、price。未设置第2

和第3个参数时，quan的值为1000,price的值为8.98。成员函数

print没有形参，需使用this指针，显示对象数据成员的内容。假设

类Stock第1个对象的三个参数分别为："600001",3000和5.67,第

2个对象的第1个数据成员的值是“600001”，第2和第3个数据成员

的值取默认值。要求编写程序分别显示这两个对象数据成员的值。

#include<iostream>

classStock{

public:

Stock(charna[],intq=1000,doublep=8.98):stockcode(na),quan(q),price(p){}

voidprint(void)

(

std::cout«this->stockcode«””«quan«”“«price«std::endl;

)

private:

char*stockcode;

intquan;

doubleprice;

);

intmain(intargc,char*argv[])

(

charszTestString[]=”600001”；

intiTestlnteger=3000;

doubledTestDouble=5.67;

StockstObj1(szTestString,iTestlnteger,dTestDouble);

StockstObj2(szTestString);

stObj1.print();

stObj2.print();

return0;

[3.36]编写一个程序，已有若干学生的数据，包括学号、姓名、成绩，要求

输出这些学生的数据并计算出学生人数和平均成绩（要求将学生人数

和总成绩用静态数据成员表示)。

#include<iostream>

usingnamespacestd;

#include<string.h>

#defineN4

classstudent

(

private:

intno;

charname[10];

intdegl;//语文成绩

intdeg2;//数学成绩

intdeg3;//英语成绩

staticintsuml;//语文总分

staticintsum2;//数学总分

staticintsum3;//英语总分

public:

student(intn,charna[],intdl,intd2,intd3)

(

no=n;

strcpy(name,na);

deg1=d1;deg2=d2;deg3=d3;

suml+=degl;sum2+=deg2;sum3+=deg3;

doubleavg1(){return(sum1*1.0)/N;}

doubleavg2(){return(sum2*1.0)/N;}

doubleavg3(){return(sum3*1.0)/N;}

voiddisp()

printf(u%4d%10s%6d%6d%6d\n",no,name,deg1,deg2,deg3);

intstudent::sum1=0;

intstudent::sum2=0;

intstudent::sum3=0;

voidmain()

double(student::*fp)();//定义成员函数指针

studentsl(l,nLin,67,89,90);

students2(2,HMan,67,89,90);

students3(3/Zheng",67,89,90);

students4(4JChen”,67,89,90);

printf(“输出结果\n");

sl.disp();

s2.disp();

s3.disp();

s4.disp();

fp=student::avgl;

printf("语文平均分%g\nn,(sl.*fp)());

fp=student::avg2;

printf(n数学平均分%g\nn,(sl.*fp)());

fp=student::avg3;

printf("英语平均分%g\n",(sl.*fp)());

第四章：

【4.8】使用派中类的主要原因是（A）o

A.提高代码的可重用性

B.提高程序的运行效率

C.加强类的封装性

D.实现数据的隐藏

[4.9]假设已经定义好了一个类student,现在要定义类derived,它是从

student私有派生的，定义类derived的正确写法是（C）。

A.clasederived::studentprivate{,•,};

B.clasederived::studentpublic{,,,};

C.clasederived::privatestudent{•,,};

D.clasederived::publicstudent{•,,};

[4.10]在多继承构造函数定义中，几个基类构造函数用（C）分隔。

A.：B.；C.,D.：：

[4.11]设置虚基类的目的是（B）o

A.简化程序B.消除二义性C.提高运行效率D.减少目标代码

[4.12]写出下面程序的运行结果。

#include<iostream>

usingnamespacestd;

classB1{

public:

Bl（inti）

{bl=i;

cout«"ConstructorBl."«endl;

}

voidPrint（）

{cout«bl«endl;

）

private:

intbl;

classB2{

public:

B2(inti)

{b2=i;

cout«*'ConstructorB2."«endl;

)

voidPrint()

{cout«b2«endl;

)

private:

intb2;

);

classA:publicB2,publicBl{

public:

A(inti,intj,int1);

voidPrint();

private:

inta;

);

A::A(inti,intj,intl):Bl(i),B2(j)

{a=l;

cout«"ConstructorA.n«endl;

)

voidA::Print()

{Bl::Print();

B2::Print();cout«a«endl;

intmain()

{Aaa(3,2,l);

aa.Print();

return0;

)

运行结果：

ConstructorB2.

ConstructorB1.

ConstructorA.

3

2

1

[4.13]写出下面程序的运行结果。

#include<iostream>

usingnamespacestd;

classMain{

protected:

char*mainfbod;

public:

Main(char求name)

{mainfood=name;

)

)；

classSub{

protected:

char*subfood;

public:

Sub(char*name)

{subfood=name;

classMenu:publicMain,publicSub{

public:

Menu(char*m,char*s):Main(m),Sub(s)

{}

voidshow();

);

voidMenu::show()

{cout<<“主食="<<mainfood«endl;

cout<<“副食二”《subfood«endl;

)

intmain()

{Menum(nbread',；,steakn);

m.show();

return0;

)

运行结果

主食二bread

副食二steak

[4,14]写出下面程序的运行结果。

#inc1ude<iostream>

usingnamespacestd;

classA{

private:

inta;

public:

A()

{a=0;}

A(int