浙大远程面向对象程序设计离线作业答案

浙江大学远程教育学院

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

姓名：董建良学号：

年级：2015年秋学习中心：杭州学习中心

第2章

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

//thisisastrange/*waytodoacomment*/

答：此注释有效，单行注释中可以嵌套/*……*/方式的注释。

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

^include<iostream>

usingnamespacestd;

intmain()

{inta,b,c;

cout«"Entertwonumbers:";

cin»a»b;

c=suni(a,b);

coul«”sumis:"«c;

return0;

)

sum(inta,intb)

{returna+b;

)

答：不可能通过编译，sum的使用在其声明之前是非法的，应增加一行sum(inta,intb);放在

usingnamespacestd;之后。

【2.5】答复以下问题。

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

floatfun(inta,floatb,char*c);

floatfun(int,float,char*);

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

floatfun(inta,floatb,char*c);

floatfun(int,float,char*);

答：

(1)两个函数原型等价，因为函数原型中的参数名可以缺省。

(2)两个函数的第一行不等价，因为函数的第一行必须包括参数名。

[2.6]以下语句中错误的选项是(D)。

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

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

[2.7]假设已经有定义"constchar*constname二〃chen";"下面的语句中正确的选项

是(D)0

A.name[3]=,a,;B.name=MlinM;

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

[2.8]假设已经有定义“char*constname="chcn";"下面的语句中正确的选项是(A)。

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

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

[2.9]假设已经有定义“constchar*name=〃chen";”下面的语句中错误的选项是(A)。

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

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]下面的类型声明中正确是⑴）。

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

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

[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+I;

cout«::i«endl;

reluiii0;

}

答：运行结果是

101

因为::i=i+l;中::i是全局变量，i是局部变量。

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

#include<iostrcam>

usingnamespacestd;

voidf(int&m,intn)

{inttemp;

temp=m;

m=n;

n=temp;

)

intmain()

{inta=5,b=10;

f(a,b);

cout«a«""«b«endl;

return0;

)

答：运行结果是

1010

因为函数f(int&m,intn)中第一个参数是引用参数，引用函数是一种按地址传递参数的

方法，对它的调用是传地址调用，第二个参数是变量参数，对它的调用是传值调用。

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

#include<iostream>

usingnamespacestd;

int&f(int&i)

{i+=10;

returni;

)

ininiain()

{intk=();

int&m=f(k);

cout«k«endl;

m=2O;

cout«k«endl;

return0;

)

答：运行结果是

10

20

因为函数f参数是变量的引用，对它的调用是传地址调用，函数f调用后，k的值变

为10,而m是对函数f的引用，m被赋值20,k的值也变为20.

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

答：例如：

#include<iostream.h>

#defineA1+2

#defineBA*4

voidmain()

{cout«B«endl;}

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

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

#include<iostream.h>

constA=1+2;

constB=A*4;

voidmain()

{cout«B«endl;}

运行结果为12o

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

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

答:

#iiiclude<ioslreani.h>

intmain()

(

int*p=newint[20];

*P=1；

*(p+l)=l;

cout«5icp«"\t"«*(p+l)«',\t";

P=p+2；

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

{

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

cout«*p«,,\f;

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

P++；

}

return0;

)

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

根。重载srool()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«"i的二次方根是:"«sroot(i)«endl;

cout«z，l的二次方根是/«sroot(1)«endl;

cout«*d的二次方根是/«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«”sumisz，«sum«endl;

return0;

)

【2.25］编写一个C++风格的程序，输入两个整数，将它们按由小到大的顺序输出。要求

使用变量的引用。

答：

#include<iostream>

usingnamespacestd;

voidchange(int&,int&);

intmainO

{

inta,b;

cin»a»b;

if(a>b)

change(a,b);

cout«a«**«b«endl;

return0;

}

voidchange(int&m,int&n)

{inttemp;

temp=m;

m=n;

n=temp;

cC'F:\面向对象程序设计'图片\Debug\2.25.exe"□X

57

5

8716

Pressanykeytocontinue

第三章:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

[3,11]在下面有关静态成员函数的描述中，正确的选项是（B）。

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

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

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

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

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

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

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

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

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

[3.13]友元的作用之一是（A）。

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

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

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

#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(intijntj):c(i,j)

()

voidA::printa()

{c.printb();

)

intmain()

{Aa(7,8);

a.printa();

return0;

)

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

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

#include<iostrcam>

usingnamespacestd;

classA)

public:

voidset(inti,intj)

{x=i;

y=i；

)

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;

1

private:

inilength,width;

Alabel;

)；

intmain()

{boxb;

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

cout«b.gct_area()«endl;

return0;

)

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

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

#include<iostream>

usingnamespacesld;

classSample!

public:

Sample(inti,intj)

{x=i;

y=j；

)

voiddisp()

{cout«"displ"«cndl;

I

voiddisp()const

{cout«"disp2"«endl;

}

private:

intx,y;

)；

intmain()

{constSamplea(1,2);

a.dispO;

reluni0;

1

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

[3,17]以下程序的运行结果是山)。

#include<iostream>

usingnamespacestd;

classR{

public:

R(intrl,intr2)

{Rl=rl;

R2=r2;

)

voidprint();

voidprint()const;

private:

intRl,R2;

)；

voidR::print()

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

)

voidR::print()const

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

)

intmain()

{Ra(6,8);

constRb(56,88);

b.print();

return0;

)

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

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

4iiickick:<iusUcaiii>

usingnamespacestd;

classtoy

{public:

toy(intq,intp)

{quan=q;

pnce=p;

1

intget_quan()

{returnquan;

)

intget_price()

{returnprice;

)

private:

intquan,price;

)；

intmain()

{toyop[3]⑵={

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

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

toy(90,16),toy(11,120),

)；

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

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

coul«op[i][0].get_price()«^'\n'^;

cout«op[i][1].get_quan()«,',M;

cout«op[i][I].get_price()«"\n";

)

cout«endl;

return0;

)

答：运行结果是

10,20

30,48

50,68

70,80

90,16

11,120

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

#include<iostream>

usingnamespacestd;

classexample

{public:

examplc(intn)

{i=n;

cout«,,Constructing\n,';

)

〜example。

{cout«"Destructing\nM;

)

intgct_i()

{returni;

)

private:

inti;

)；

intsqr_it(exampleo)

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

)

intmain()

{examplex(10);

coul«x.gcl_i()«cndl;

cout«sqr_it(x)«endl;

return0;

)

答：运行结果是

Constructing

10

Destructing

100

Destructing

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

#include<iostream>

usingnamespacesld;

classaClass

{public:

aClass()

{total

)

-aClass()

{total—;

I

intgettotal()

{returntotal;

)

private:

staticinttotal;

)；

intaClass::total=0;

intmain()

{aClassol,o2,o3;

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

aClass*p;

p=newaClass;

if(!p)

{cout«"Allocationenor\n*';

returnI;

}

cout«oi.gcttotal();

cout«nobjectsinexistenceafterallocation\nu;

deletep;

cout«ol.gettotal();

cout«"objectsinexistenceafterdeletion\nH;

return0;

)

答：运行结果是

3objectsinexistence

4objectsinexistenceafterallocation

3objectsinexistenceafterdeletion

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

#include<iostream>

usingnamespacestd;

classtest

{public:

test();

~test(){};

private:

inti;

)；

test::test()

{i=25;

for(intctr=();ctr<l();ctr++)

{cout«"Countingat"«ctr«n\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«"DefaultconstructorcalledAn',;

)

A(inti,intj)

{a=i;

b=j；

coul«"Cuii5lruulor:a="«a«",b-n«b«t;ii(Jl;

1

)；

intmain()

{Aa[3];

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

return0;

I

答：运行结果是

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«"default.H«endl;

}

Test(intn)

{val=n;

cout«"Con.',«endl;

I

Test(constTest&t)

{val=t.val;

uuul«"Copycon.u«eiidl;

)；

intmain()

{Test11(6);

Testt2=tl;

lestt3;

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=M«m.A«endl;

cout«HB="«B«endl;

)

intN::B=();

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=0;

)

M(inti,intj)

{x=i；

y=j；

)

voidcopy(M*m);

voidsetxy(inti,intj)

{x=i;

y=j；

}

voidpiinl()

{cout«x«",n«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);

p.print();

q.printO；

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;

coul«"B=H«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]指出以下程序中的错误，并说明为什么。

#inckide<iostream>

usingnamespacestd;

classStudent(

public:

voidprintStu();

private:

charname[10];

intage;

floataver;

)；

intmain()

{Studentpl,p2,p3;

pl.agc=30;

return0;

)

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

接访问。

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

#include<iostream>

usingnamespacestd;

classStudent(

intsno;

intage;

voidprintStu();

voidsetSno(intd);

}；

voidprintStu();

{uoul«,'\iiSnois"«bnu«",";

cout«"ageis"«age«u.H«endl;

)

voidsetSno(ints)

{sno=s;

)

voidsetAge(inta)

{age=a;

)

intmain()

{Studentlin;

lin.setSno(20021);

lin.selAge(20);

lin.printStu();

)

答：有三个错误：

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

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

第二，成员函数printStuO和setSno(intd)在类外定义，应加上类名“Student：："

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

【3.29】指出以下程序中的错误，并说明为什么。

#include<iostream>

usingnamespacestd;

classPoint{

public:

intx,y;

private:

Piont()

{x=l;y=2;

)

）；

ininiaiii()

{Pointcpoint;

cpoint.x=2;

return0;

)

答：有两个错误：

第一：构造函数名应与类名相同，“3ont()”应改为“Point。"；

第二，构造函数Point。是私有的，所以语句“Point叩oint;”执行时出现错误，原因

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

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

classcounter)

public:

counter(intnumber);

voidincrement();〃给原值加1

voiddecrement();〃给原值减1

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

intprint();〃显示计数

private:

intvalue;

}；

答：完整程序如下

classcounter{

public:

counter(intnumber);

voidincrement();

voiddecrement();

intgetvalueO;

intprint();

private:

intvalue;

｝；

//成员函数的实现

counter::counter(intnumber)

{value=number;}

voidcounter::increment()

{value++;}

voidcounter::decrement()

{value—;}

intcounter::getvalue()

{returnvalue;}

intcounter::print()

{cout«wvalueisa«value«endl;

return0;

)

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

#include<iostream>

usingnamespacestd;

classDate{

public:

voidprintDate();〃显示日期

voidsctDay(intd);〃设置日的值

voidsetMonth(intm);〃设置月的值

voidsetYear(inty);〃设置年的值

private:

intday,month,year;

）；

intmain()

{DatetestDay;

testDay.setDay(5);

testDay.setMonth(10);

testDay.setYear(2()()3);

testDay.printDate();

reluni0;

}

答：类Date的成员函数如下

voidDate::printDate()

(

cout«*Dateis"«day<<"."；

cout«month«z，.*«year«endl;

)

voidDate::setDay(intd)

{day=d;}

voidDate::setMonth(intm)

{month=m;}

voidDate::setYear(inty)

{year=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«/zvolumeis:"<<voluine<<"\n";}

intmainO

(

cylinderx(4.5,6.88);

x.vol();

return0;

}

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

将price初始化为qu的10倍，建立一个有5个元素的数组对象。显示每个对象

数组元素的qu*pricc值。

答：

#include<iostream>

usingnamespacestd;

classbook{

public:

book(inta,intb)

{qu=a;

price=b;}

voidshow_money()

{cout«qu*price«zr\n*;}

private:

intqu,price;

)；

intmainO

(

bookob[5]={book(1,10),book(2,20),book(3,30),book(4,40),book⑸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()

{cout«qu*price«z，\nz，;}

private:

intqu,price;

}；

intmainO

{bookob[5]={book(1,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个

参数分别赋给quau>price。木设置第2和第3个参数时，quail的值为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;

StockstObjl(szTestString,iTestlnteger,dTestDouble);

Stockst0bj2(szTestString);

stObjl.print();

st0bj2.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);

degl=dl;deg2=d2;deg3=d3;

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

)

doubleavgl(){return(suml*l.0)/N;}

doubleavg2(){return(sum2*l.0)/N;}

doubleavg3(){return(sum3*l.0)/N;}

voiddisp()

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

)

｝；

intstudent::suml=0;

intstudent::sum2=0;

intstudent::sum3=0;

voidmainO

(

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

studentsi(1,"Li”,67,89,90);

students2(2,"Ma”,67,89,90);

students3⑶"Zheng”,67,89,90);

students4(4,"Chen”,67,89,90);

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

si.disp();

s2.disp();

s3.disp();

s4.disp();

fp=student::avgl;

printfC语文平均分%g\n",(si.*fp)());

fp二student::avg2;

printfC数学平均分%g\n\(si.*fp)());

fp=student::avg3;

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

)

第四章：

[4.8]使用派中类的主要原因是(AL

A.提高代码的可重用性

B.提高程序的运行效率

C.加强类的封装性

D.实现数据的隐藏

【4.9］假设己经定义好了一个类student,现在要定义类derived,它是从student私有

派生的，定义类derived的正确写法是(C)o

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

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

C.clasederived::privatestudent{,,,);

D.clasederived::publicstudent(•••};

［4.10］在多继承构造函数定义中，几个基类构造函数用(C)分隔。

A.：3.；C.,D.：：

［4.11］设置虚基类的目的是(B)。

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

［4.12］写出下面程序的运行结果。

#include<ioslream>

usingnamespacestd;

classB1{

public:

Bl(inti)

{bl=i;

cout«"ConstructorBl.H«endl;

)

voidPrint()

{cout«bl«endl;

)

private:

intbl;

)；

classB2{

public:

B2(inti)

(b2=i;

cout«nConstructorB2.u«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."«endl;

)

voidA::Print()

{Bl::Print();

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

)

intmain()

{Aaa(3,2J);

aa.Print();

return0;

)

答：

ConstructorB2.

ConstructorBl.

ConstructorA.

3

2

1

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

#include<iostream>

usingnamespacestd;

classMain{

protected:

char*mainfood;

public:

Main(char*name)

{mainfood二name;

)

)；

classSub{

protected:

char*subfood:

public:

Sub(char*name)

{subfood=name;

I