面向对象程序设计离线作业答案.docx

面向对象程序设计离线作业答案.docx

《面向对象程序设计离线作业答案.docx》由会员分享，可在线阅读，更多相关《面向对象程序设计离线作业答案.docx（53页珍藏版）》请在冰豆网上搜索。

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

浙江大学远程教育学院

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

第2

【】测试下面的注释（它在C++风格的单行注释中套入了类似于C的注释）是否有效。

name[3]='a';B.name="lin";

C.name=newchar[5];D.cout<

【】假设已经有定义“char*constname="chen";”下面的语句中正确的是（A）。

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

C.name=newchar[5];D.name=newchar（'q'）;

【】假设已经有定义“constchar*name="chen";”下面的语句中错误的是（A）。

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

C.name=newchar[5];D.name=newchar（'q'）;

】重载函数在调用时选择的依据中,（B）是错误的。

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

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

】在（A）情况下适宜采用内联函数。

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

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

【】下列描述中，（C）是错误的。

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

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

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

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

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

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

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

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

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

】下面的类型声明中正确是（D）。

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

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

】下面有关重载函数的说法中正确的是（C）。

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

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

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

D.重载函数名可以不同

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

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

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

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

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

】关于delete运算符的下列描述中,（C）是错误的。

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

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

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

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

】写出下列程序的运行结果。

#include

usingnamespacestd;

inti=15;

intmain（）

{inti;

i=100;

:

:

i=i+1;

cout<<:

:

i<

return0;

答：

101

】写出下列程序的运行结果

#includeusingnamespacestd;voidf（int&m,intn）{inttemp;temp=m;

m=n;n=temp;

}

intmain（）

{inta=5,b=10;

f（a,b）;

cout<

}

答：

1010

】分析下面程序的输出结果。

#includeusingnamespacestd;int&f（int&i）{i+=10;

returni;

}

intmain（）

{intk=0;

int&m=f（k）;cout<

m=20;cout<

return0;

}

答：

10

20

【】举例说明可以使用const替代#define以消除#define的不安全性。

答：

例如#include<>

#defineA2+4

#defineBA*3

voidmain（）

{

coutvvBvvendl;

}

上面程序的运行结果是14而不是18但很容易被认为是18。

用const替代

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

#include<>

constA=2+4;

constB=A*3;

voidmain（）

{

coutvvBvvendl;

}

运行结果为18。

【】编写一个C++风格的程序，用动态分配空间的方法计算Fibonacci数列的前20项，并存储到动态分配的空间中。

#include

usingnamespacestd;

intmain（）

inti;

int*p;

p=newint[20];

p[0]=0;

p[1]=1;

cout<<*p<<""<<*（p+1）<<"";

for（i=2;i<20;i++）

{

p[i]=p[i-2]+p[i-1];

cout<<*（p+i）<<"";

}

deletep;

return0;

}

【】编写一个C++风格的程序，建立一个被称为sroot（）的函数，返回其参数的二

次方根。

重载sroot（）3次,让它返回整数、长整数与双精度数的二次方根（计算二次方根时，可以使用标准库函数sqrt（））。

#include<>

#include<>

intsroot（intx）

{

return

（int）sqrt（x）;

}

floatsroot（floatx）

{

return

（float）sqrt（x）;

}

doublesroot（doublex）

return（double）sqrt（x）;

}

voidmain（）析构函数名与类名完全相同

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

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

【】构造函数是在（B）时被执行的。

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

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

【】在下面有关静态成员函数的描述中，正确的是（B）。

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

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

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

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

【】在下面有关友元函数的描述中，正确的说法是〔A）。

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

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

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

D.在外部定义友元函数时，必须加关键字friend【】友元的作用之一是（A）。

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

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

【】以下程序运行的结果是（B）。

#include

usingnamespacestd;

classB{

public:

B（）{}

B（inti,intj）

{x=i;

y=j;

voidprintb（）

{cout<

}private:

intx,y;

};

classA{

public:

A（）

{}

A（intI,intj）;voidprinta（）;

private:

Bc;

};

A:

:

A（inti,intj）:

c（i,j）

{}

voidA:

:

printa（）

{（）;

}

intmain（）

{Aa（7,8）;

（）;

return0;

}

D.9,10

A．8,9B.7,8C.5,6

】以下程序的运行结果是（A）。

usingnamespacestd;

classA{

public:

voidset（inti,intj）

{x=i;

y=j;

}

intget_y（）

{returny;

}

private:

intx,y;

};

classbox{

public:

voidset（intl,intw,ints,intp）{length=1;

width=w;

（s,p）;

}

intget_area（）

{returnlength*width;

}

private:

intlength,width;

Alabel;

};

intmain（）

{boxb;

（4,6,1,20）;

C.20D.6

D.程序编译出错

cout<<（）<

return0;

A．24B.4

】以下程序的运行结果是（B）。

#include

usingnamespacestd;

classSample{

public:

Sample（inti,intj）

{x=i;

y=j;

}

voiddisp（）

{cout<<"disp1"<

}

voiddisp（）const

{cout<<"disp2"<

}

private:

intx,y;

};

intmain（）

{constSamplea（1,2）;

（）;

return0;

}

A.disp12C.disp1disp2】以下程序的运行结果是（B）。

usingnamespacestd;

classR{

public:

R（intr1,intr2）

{R1=r1;

R2=r2;

}

voidprint（）;

voidprint（）const;

private:

intR1,R2;

};

voidR:

:

print（）

{cout<

}

voidR:

:

print（）const

{cout<

}

intmain（）

{Ra（6,8）;

constRb（56,88）;

（）;

return0;

}

D.8,6

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

】写出下面程序的运行结果。

#includeusingnamespacestd;

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（11,120）,

};

for（inti=0;i<3;i++）

{cout<

cout<

cout<

cout<

}

cout<

return0;

}

10，20

30，

48

50，

68

70，

80

90，

16

11，

120

】写出下面程序的运行结果。

#includeusingnamespacestd;classexample{public:

example（intn）{i=n;cout<<"Constructing\n";

}

~example（）

{cout<<"Destructing\n";

}

intget_i（）

{returni;

}private:

inti;

};

intsqr_it（exampleo）{return（）*（）;

}

intmain（）

{examplex（10）;cout<<（）<

return0;

}

10

100

Destructing

Destructing

】写出下面程序的运行结果。

#includeusingnamespacestd;classaClass

{public:

aClass（）

{total++;

}

~aClass（）

{total--;

}

intgettotal（）

{returntotal;

}

private:

staticinttotal;

};

intaClass:

:

total=0;

intmain（）

{aClasso1,o2,o3;cout<<（）<<"objectsinexistence\n";aClass*p;

p=newaClass;

if（!

p）

{cout<<"Allocationerror\n";return1;

}

cout<<（）;

cout<<"objectsinexistenceafterallocation\n";deletep;

cout<<（）;

cout<<"objectsinexistenceafterdeletion\n";return0;

}

3objectsinexistence

4objectsinexistenceafterallocation

3objectsinexistenceafterdeletion

】写出下面程序的运行结果。

#include

usingnamespacestd;

classtest

{public:

test（）;

~test（）{};

private:

inti;

};

test:

:

test（）

{i=25;

for（intctr=0;ctr<10;ctr++）

{cout<<"Countingat"<

}

}

testanObject;

intmain（）

{return0;

}

Countingat0

Countingat1

Countingat2

Countingat3

Countingat4

Countingat5

Countingat6

Countingat7

Countingat8

Countingat9

】写出下面程序的运行结果。

#include

usingnamespacestd;

classA{

inta,b;

public:

A（）

{a=0;

b=0;

cout<<"Defaultconstructorcalled.\n";

}

A（inti,intj）

{a=i;

b=j;

cout<<"Constructor:

a="<

intmain（）

{Aa[3];

Ab[3]={A（1,2）,A（3,4）,A（5,6）};return0;

}

Defaultconstructorcalled.

Defaultconstructorcalled.

Defaultconstructorcalled.Constructor:

a=1,b=2

Constructor:

a=3,b=4

Constructor:

a=5,b=6

】写出下面程序的运行结果。

#includeusingnamespacestd;classTest{

private:

intval;

public:

Test（）

{cout<<"default."<

}

Test（intn）

{val=n;cout<<"Con."<

}

Test（constTest&t）

{val=;

cout<<"Copycon."<

intmain（）

{Testt1（6）;Testt2=t1;

Testt3;t3=t1;return0;

}

Con.

Copycon.

Default.

】写出下面程序的运行结果。

#includeusingnamespacestd;classN{private:

intA;staticintB;

public:

N（inta）{A=a;

B+=a;

}

staticvoidf1（Nm）;};

voidN:

:

f1（Nm）{cout<<"A="<<<

}

intN:

:

B=0;

intmain（）

{NP（5）,Q（9）;

N:

:

f1（P）;

N:

:

f1（Q）;

return0;

}

A=5

B=14

A=9

B=14

】写出下面程序的运行结果。

#includeusingnamespacestd;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;

}voidprint（）{cout<

}

};

voidM:

:

copy（M*m）

{x=m->x;

y=m->y;

}

voidfun（Mm1,M*m2）{（12,15）;

m2->setxy（22,25）;

}

intmain（）

{Mp（5,7）,q;

（&p）;

fun（p,&q）;

（）;

（）;

return0;

}

5,7

22,25

】写出下面程序的运行结果。

#includeusingnamespacestd;

classM{

intA;

staticintB;

public:

M（inta）

{A=a;

B+=a;

cout<<"Constructing"<

}staticvoidf1（Mm）;

~M（）

{cout<<"Destructing\n";

}

};

voidM:

:

f1（Mm）

{cout<<"A="<<<

}

intM:

:

B=0;

intmain（）

{Mp（5）,Q（10）;

M:

:

f1（p）;

M:

:

f1（Q）;

return0;

}

Constructing

Constructing

A=5

B=15

Destructing

A=10

B=15

Destructing

Destructing

Destructing

】指出下列程序中的错误，并说明为什么#includeusingnamespacestd;

classStudent{

public:

voidprintStu（）;

private:

charname[10];

intage;

floataver;

};

intmain（）

{Studentp1,p2,p3;

=30;

return0;

}age为private不能付值

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

#include

usingnamespacestd;

classStudent{

intsno;

intage;

voidprintStu（）;

voidsetSno（intd）;

};

voidprintStu（）;

{cout<<"\nSnois"<

}

voidsetSno（ints）

{sno=s;

}

voidsetAge（inta）

{age=a;

}

intmain（）

{Studentlin;

（20021）;

（20）;

（）;

}'classStudent'不存在一个叫'setAge'的方式】指出下列程序中的错误，并说明为什么。

#include

usingnamespacestd;

classPoint{

public:

intx,y;

private:

Piont（）

{x=1;y=2;

}

};

intmain（）

{Pointcpoint;

=2;

return0;

}

构筑函数错误

】下面是一个计算器类的定义，请完成该类成员函数的实现classcounter{

public:

counter（intnumber）;

voidincrement（）;<

};

intmain（）

{DatetestDay;

（5）;

（10）;

（2003）;

（）;

return0;

}

【】建立类cylinder,cylinder的构造函数被传递了两个double值，分别表示圆柱体的半径和高度。

用类cylinder计算圆柱体的体积，并存储在一个double变量中。

在类cylinder中包含一个成员函数vol，用来显示每个cylinder对象的体积。

#include

usingnamespacestd;

#definePI

classCylinder

{

public:

Cylinder（doubleradius,doubleheight）:

radius（radius）,height（height）,volume（PI*radius*radius*height）

{

total_vol+=volume;

}

doublevol（）const;friendvoidgetParas（double&radius,double&height,double&vol,double&total_vol,constCylinder&obj）;

private:

doubleradius;et_qu（）*obj[i].get_price（）<

}

}

【】修改习题，通过对象指针访问对象数