面向对象程序设计复习题.docx

面向对象程序设计复习题.docx

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

面向对象程序设计复习题

面向对象程序设计复习题

一、概念填空题

1.运算符能够用来访问与局部变量同名的全局变量。

2.运算符动态分配一个对象。

3.类的成员只能被该类的成员函数或友元函数访问。

4.类成员的默认访问模式是的。

5.类的数据成员是该类的所有对象共享的信息。

6.关键字指定了不可修改的对象或变量。

7.要在类的对象上使用运算符,除了运算符和外,其它的必须都要被重载。

8.重载不能改变原运算符的、、和对内部类型对象的原有含义。

9.类的对象可作为类的对象处理。

10.友元函数中可以直接访问类的和成员。

1l.公有成员函数的集合常称为类的函数。

私有成员函数的集合常称为类的函数。

12.为了访问某个类的私有数据成员,必须在该类中声明该类的。

13.提供了一种描述通用类的方法。

14.运算new分配的内存要用运算符回收。

15.参数表示重载后缀++运算符函数。

16.当用受保护的继承从基类派生一个类时,基类的公有成员成为派生类的

的成员,基类的受保护成员成为派生类的成员。

17.在C++中,关键字、和用来建立新的数据类型。

18.限定符用来声明只读变量。

19.函数能够定义一个在不同数据类型基础上完成同一任务的函数。

20.指向基类对象的指针可以指向其派生类的对象，但是不允许指向其派生类的对象。

答案：

1:

:

2new3私有和保护4私有5静态6const7=&

8优先级结合性操作数个数9派生类基类10私有受保护

11接口工具12友元13类模板14delete15int

16受保护受保护17classstructunion18const

19模板20公有私有和保护

二、阅读程序写结果

1．#include

voidmain（）

{

inta（6）,b（8）,c;

c=（a>b?

++a:

b-=2）;

cout<

c=（a-b?

a+b:

a-6?

b:

a-6）;

cout<

}

输出结果：

答案：

输出结果：

6，6，6

6，6，0

2．#include

voidmain（）

{

inti,j;

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

{

for（j=2;j

if（i%j==0）

break;

if（j!

=i）

cout<

}

cout<

}

输出结果：

答案：

1214151618

3．#include

#include

intf（intp）;

voidmain（）

{

inta[]={1,2,3,4,5};

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

cout<

cout<

}

intf（intp）

{

staticints=1;

s*=p;

returns;

}

输出结果：

12624120

4．#include

intf（int*p）;

voidmain（）

{

inta[]={1,2,3,4,5}

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

cout<

cout<

}

intf（int*p）

{

staticints=0;

s+=*p;

returns;

}

输出结果：

1361015

4．

#include

voidmain（）

{

inta[5],x,i=0;

do

{

cin>>x;

if（x%2==0）

{

a[i]=x;

i++;

}

}while（i<5）;

for（i=0;i<5;i++）

cout<

cout<

}

输入：

165820710

输出结果：

682010

5．#include

classmyclass

{

private:

inta,b;

staticints;

public:

myclass（inti,intj）

{

a=i;b=j;

cout<<"Constructor.\n";

}

~myclass（）

{

cout<<"Destructor.\n";

}

voidsum（）

{s+=a*b;}

voidprint（）

{

cout<

}

};

intmyclass:

:

s=0;

voidmain（）

{

myclass*a1,*a2;

a1=newmyclass（1,1）;

a2=newmyclass（10,20）;

（*a1）.sum（）;

（*a2）.sum（）;

a1->print（）;

a2->print（）;

deletea1;

deletea2;

}

输出结果：

Constructor.

Constructor.

1,1sum=201

10,20sum=201

Destructor.

Destructor.

6．

#include

classDate

{

private:

intyear;

intmonth;

intday;

public:

Date（inty,intm,intd）

{

year=y;

month=m>0&&m<13?

m:

0;

switch（month）

{

case0:

d=0;break;

case1:

case3:

case5:

case7:

case8:

case10:

case12:

day=（d>0&&d<32?

d:

0）;break;

case4:

case6:

case9:

case11:

day=（d>0&&d<31?

d:

0）;break;

case2:

day=（isleapyear（）?

（d>0&&d<30?

d:

0）:

（d>0&&d<29?

d:

0））;break;

}

}

intisleapyear（）

{

return!

（year%4!

=0||year%400==0&&year%100!

=0）;

}

voidprint（）

{

if（year<0）

cout<<"公元前"<<-year<<"年";

else

cout<<"公元"<

if（month）

cout<

else

cout<<"月份不详！

";

if（day）

cout<

else

cout<<"日期不详！

";

cout<

}

};

voidmain（）

{

Dated1（1949,10,1）,d2（2004,2,29）,d3（-996,4,31）;

d1.print（）;

d2.print（）;

d3.print（）;

}

输出结果：

公元1949年10月1日

公元2004年2月29日

公元前996年4月日期不详！

7．#include

classA

{

private:

inta,b;

public:

A（inti,intj）

{a=i;b=j;}

voidmove（intm,intn）

{

a+=m;

b+=n;

}

voidshow（）

{

cout<<"（"<

}

};

classB:

publicA

{

private:

intx,y;

public:

B（inti,intj,intk,intl）:

A（i,j）

{x=k;y=l;}

voidshow（）

{cout<

voidfun（）{move（30,50）;}

voidf1（）{A:

:

show（）;}

};

voidmain（）

{

Ae（10,20）;

e.show（）;

Bb（30,40,50,60）;

b.fun（）;

b.show（）;

b.f1（）;

}

输出结果：

（10,20）

50,60

（60,90）

8.#include

classB{

private:

intY;

public:

B（inty=0）{Y=y;cout<<″B（″<

～B（）{cout<<″～B（）\n″;}

voidprint（）{cout<

};

classD:

publicB{

private:

intZ;

public:

D（inty,intz）:

B（y）

{Z=z;

cout<<″D（″<

}

～D（）{cout<<″～D（）\n″;}

voidprint（）{

B∶∶print（）;

cout<

}

};

voidmain（）

{Dd（11,22）;

d.print（）;

}

输出结果：

B（11）

D（11,22）

112

~D（）

~B（）

9．

#include

classPoint

{

private:

intxcord,ycord;

public:

Point（intx,inty）

{xcord=x;ycord=y;}

voidmove（intx1,inty1）

{

xcord+=x1;

ycord+=y1;

}

voidshow（）

{

cout<<"（"<

}

};

classCircle:

publicPoint

{

private:

intradius;

public:

Circle（intx,inty,intr）:

Point（x,y）

{radius=r;}

voidshow（）

{cout<<"圆心坐标：

";Point:

:

show（）;cout<<"半径：

"<

};

voidmain（）

{

Circlec（10,20,5）;

c.show（）;

c.move（-5,5）;

c.show（）;

}

输出结果：

圆心坐标：

（10,20）半径：

5

圆心坐标：

（5,25）半径：

5

10.#include

classA

{

private:

doubleX,Y;

public:

A（doublexx=0,doubleyy=0）

{X=xx;Y=yy;

cout<<″构造函数被调用（″<

}

A（A&p）{X=p.X;Y=p.Y;}

};

Af（）

{Aa（1,2）;

returna;

}

voidmain（）

{Aa（4,5）;Ab（a）;

b=f（）;

}

输出结果：

构造函数被调用（4,5）

构造函数被调用（1,2）

11.#include

classA{

public:

virtualvoidf（）{cout<<″A:

:

f（）\n″;}

};

classB:

publicA

{

private:

char*buf;

public:

B（inti）{

buf=newchar［i］;

}

voidf（）{

cout<<″B:

:

f（）\n″;

}

～B（）{delete［］buf;}

};

voidmain（）

{A*a=newA;

a->f（）;deletea;

a=newB（15）;a->f（）;

}

输出结果：

A:

:

f（）

B:

:

f（）

12.#include

voidmain（）

{inta［9］={1,2,3,4,5,6,7,8,9};

for（inti=0;i<9;i++）{

cout<

if（i%3==2）

cout<

}

}

输出结果：

123

456

789

13.#include

template

voidprint（Ta［］,intn）

{for（inti=0;i

{cout<

if（i%5==4）

cout<

}

cout<

}

voidmain（）

{

inta［］={1,2,3,4,5,6,7};

doubleb［4］={8,9,10,11};

print（a,sizeof（a）/sizeof（int））;

print（b,4）;

}

输出结果：

答案：

12345

67

891011

14.#include

classA

{

private:

staticintn;

intX;

public:

A（intx=0）{X=x;n++;}

～A（）{n--;}

staticintGetNum（）{returnn;}

voidprint（）;

};

voidA∶∶print（）{cout<<″n=″<

intA∶∶n=0;

voidmain（）

{A*p=newA（12）;

p->print（）;

Aa（34）;

a.print（）;

deletep;

cout<<″n=″<

:

GetNum（）<

}

输出结果：

n=1,X=12

n=2,X=34

n=1

15.#include

voidmain（void）

{intn=6,k;

cout<

for（k=2;k

if（n%k==0）

cout<

cout<

}

输出结果：

6Factors23

16.#include

classB{

public:

virtualintf（）{return0;}

};

classD:

publicB{

public:

intf（）{return100;}

};

voidmain（）{

Dd;

B&b=d;

cout<

cout<

:

f（）<

}

输出结果：

100

0

三、程序填空

1.菲波纳齐数列为：

1，1，2，3，5，8，13，……；下面是实现计算该数列前10项的程序，请在空白处填入合适的内容。

#include

longfa（intm）//递归函数

{

longf;

if（m>2）

____________

else

_____________

returnf;

}

voidmain（）

{

for（inti=1;i<11;i++）

cout<<______<<“　　”;

cout<

}

答案：

f=fa（n-1）+fa（n-2）;

f=1;

fa（i）

2.下面是实现字符在字符串中出现频率的程序，请在空白处填入合适的内容。

#include

intnchar（char*s,charc）

{

intn（0）;

for（inti=0;____________;i++）

if（s[i]==c）

n++;

_________________

}

voidmain（）

{

charstr[80],ch;

cout<<"输入字符串：

";

cin>>str;

cout<<"输入一个字符：

";

cin>>ch;

cout<

"<<______________<

}

答案：

s[i]

returnn;

nchar（str,ch）

3.下面是将一个一维数组及各元素乘积写入文本文件data.txt的程序，请在空白处填入合适的内容。

_________________

#include

voidmain（）{

inta[10]={1,2,3,4,5,6,7,8,9,10},cum=0;

_____________________

if（!

fout）{//打开文件失败

cout<<"Cannotopenthefile!

"<

exit

（1）;

}

inti;

for（i=0;i<10;i++）{

cum*=a[i];

_________________//将数组元素写入文件

}

_________________//将元素的乘积写入文件

fout.close（）;

}

答案：

#include

ofstreamfout（"data.txt"）;

fout<

fout<

4.下面是一个判断一个整数是否素数的程序，请在空白处填入合适的内容。

#include

classinteger{

intnumber;

public:

integer（intn）{________________}

intgetnum（）{returnnumber;}

boolisprime（）{

for（inti=2;i

if（number%i==0）

break;

if（______________）

returntrue;

else

returnfalse;

}

};

voidmain（）{

integern1（19）;

if（_______________）

cout<

"<

else

cout<

"<

}

答案：

number=n;

number==i;

n1.isprime（）

5.下面是利用运算符重载实现字符串赋值（=）的程序，请在空白处填入合适的内容。

#include

#include

classCstring

{char*s;

public:

Cstring（char*s1=0）{

s=newchar[strlen（s1）+1];

strcpy（s,s1）;

}

__________________________

voidlist（）{cout<

};

CstringCstring:

:

operator=（Cstring&s1）

{

deletes;

s=newchar[strlen（s1.s）+1];

strcpy（s,s1.s）;

____________

}

voidmain（）

{

Cstringcstr1（"abcd"）,cstr2（"1234"）;

__________________

cstr1.list（）;

}

答案：

Cstringoperator=（Cstring&s1）;

return*this;

cstr1=cstr2;

6.为使下面程序输出结果为：

1*2

3+4

请在横线处填上适当的字句，以使程序完整。

#include

classA

{

private:

intR1,R2;

public:

A（intr1,intr2）{R1=r1;R2=r2;}

voidprint（）;

voidprint（）const;

};

voidA:

:

print（）

{

cout<

}

voidA:

:

print（）const

{

cout<

}

voidmain（）

{

Aa（1,2）;

constAb（3,4）;

a.print（）;

b.print（）;

}

答案：

“*”“+”

7下面是利用运算符重载实现两个一维等长数组相加（+）的程序，请在空白处填入合适的内容。

#include

classArray

{

int*a;

intn;

public:

Array（intn1）{

__________________

n=n1;

}

voidinput（）{

for（inti=0;i

cin>>a[i];

}