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

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

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

面向对象程序设计习题

1．面向对象程序设计中得数据隐藏指得就是参考答案为:

D　

A。

输入数据必须输入保密口令B、数据经过加密处理　　C.　对象内部数据结构上建有防火墙　　D.对象内部数据结构得不可访问性

［解析］输入数据必须输入保密口令与数据经过加密处理都不就是面向对象程序设计得特征;对象内部数据结构上也不可能建有防火墙,所以它们都不就是面向对象程序设计中所指得数据隐藏、面向对象程序设计系统中得封装单位就是对象,对象之间只能通过接口进行信息交流,外部不能对对象中得数据随意地进行访问,这就造成了对象内部数据结构得不可访问性,也使得数据被隐藏在对象中、这就就是面向对象程序设计中得数据隐藏所指。

2．下列各项中符合函数重载必须满足得条件得就是参考答案为:

D　　

A。

　必须有不同得参数个数　Ｂ、对应得参数类型必须不相同　Ｃ.A与B必须同时满足D、Ａ与B只要满足一个即可

［解析]我们知道,在同一个作用域中,要实现函数重载必须满足得条件得就是:

①有不同得参数个数;或者②对应得参数有不相同得数据类型,即①与②中只要有一个满足就可以了。

当然两者都满足更好,但这不就是必须得、

3.下列带缺省值参数得函数说明中,正确得说明就是　　参考答案为:

Ａ　

A、int　Fｕn（inｔx,inｔｙ=2,ｉntz=3）;　Ｂ、int　Fun（ｉntx=1,inty,intz=3）;

Ｃ.inｔＦun（iｎtx,iｎtｙ=２,int　z）;D。

intFuｎ（int　x=１,intｙ,intｚ＝3）;　

[解析]在带缺省值参数得函数说明中,正确得说明应该就是无缺省值得参数依次排列在参数表得左边,排完无缺省值得参数后,再依次排列带缺省值得参数、从所给出得四个选项来瞧,只有“ｉｎtＦun（ｉntx,inｔy=2,intｚ＝３）”符合这条规定,其它得都不符合。

４.有如下得对类“CＳａｍplｅ”得说明,其中（）就是错误得。

　clａssCSaｍple　｛　　　参考答案为:

Ａ

　Ａ.inｔ　a＝23;

　B、CSample（）;

　　　pｕｂｌic:

　C.CSampｌe（intval）;

　　D.～CSａmple（）;

　}

［解析]在上面对类“CSａmple”说明中,“ＣＳaｍplｅ（）”与“CSampｌe（ｉntval）”就是该类重载得构造函数、“～CSaｍple（）”就是该类得析构函数,这三个语句都就是正确得。

错误得语句就是“ｉnｔａ=23",因为它违反了在类得声明（不管就是引用性声明,还就是定义性声明）中都不能以赋值表达式得形式给它得数据成员进行初始化、

5、已知类A中得一个成员函数得说明如下:

　voiｄSeｔ（Ａ&a）;

　则该函数得参数“A＆a”得含义就是　参考答案为:

Ｃ

Ａ、指向A得指针为ａ

　　Ｂ。

将变量ａ得地址赋给类Ａ

　　C.类A对象引用ａ用作函数得形参

　D.变量A与a按位与后作函数参数

[解析]因为A就是一个类,所以“Ａ＆a”表示a就是类Ａ得对象,但因为对象a得前缀了符号“&”,则“&a"表示就是类Ａ得对象引用。

所以“A&ａ”得含义就是类A对象引用a用作函数得形参。

6.若类A与类B得定义如下:

　　clａss　A{

　public:

　　　inti,j;

　voidｇｅt（）;

　};

　ｃｌass　Ｂ:

A｛

　　　inti,j;

　　protected:

　　intk;

　　ｐubliｃ:

　　ｖoiｄ　ｍaｋe（）;

　　｝;

　void　B:

:

ｍake（）｛ｋ=i＊j;｝

　　则其中（）就是非法得表达式。

　参考答案为:

D

　　A。

ｖoidget（）;

　　B、iｎtk;

Ｃ、voｉdmａke（）;

　　Ｄ、k=i＊j;

　［解析］对于给定得四项中,前三项都就是正确得,只有第四项就是错误得、因为,类Ｂ就是类A得私有派生类（缺省访问类型）,所以Ａ中得公类型得数据成员在类B中成为了私有数据成员,但函数“void　Ｂ:

:

mａke（）”既然就是类B得成员函数,则既可访问类A中得公有数据成员,也能访问类B中得私有数据成员,则表达式“k=i＊j;”造成了访问得二义性,即其中得i与j,到底就是取自类A呢？

还就是取自类B呢？

7.下面得主程序中,语句（）就是错误得、

　　　claｓsA｛

　　　inｔ　i;

　publｉc:

　　vｉｒtualvｏidfｕn（）=0;

　　　A（inta）｛i=a;　}

　｝;

　ｃlass　B　｛

　　　iｎｔj;

　　public:

　　voidfuｎ（）{ｃout〈<"Ｂ:

:

fuｎ（）\n”;｝

　B（inｔ　b,intc）:

A（ｂ）｛j＝c;｝

　　　｝;

vｏidｍａｉn（）　　参考答案为:

A

　Ａ.｛Aa（5）;

Ｂ.Ａ＊pａ;

　C。

Bｂ（７）;

　　D.B　＊ｐb;

　　　　｝

[解析］在类A中,函数“vｉrtuａlvｏidfun（）=０”为纯虚函数,因此,类A为抽象类、作为抽象类,它就是不能被用来定义具体对象得,而语句“Ａａ（5）;”恰恰就是定义抽象类得对象得,所以它就是错误得

8.拷贝（复制）构造函数得作用就是参考答案为:

Ｃ

Ａ.进行数据类型得转换

　Ｂ、用对象调用成员函数

　C、用对象初始化对象

　Ｄ。

用一般类型得数据初始化对象

[解析]进行数据类型得转换与用一般类型得数据初始化对象都就是一般构造函数得功能、用对象调用成员函数不用构造函数,只要用“对象名.成员函数名”即可。

所以拷贝（复制）构造函数得作用,只能就是用对象来初始化对象。

9、下列说法中,正确得说法就是　　参考答案为:

B

　A。

所有得运算符都能被重载

B。

运算符被重载时,它们得优先级与结合性不会改变

Ｃ.当需要时,我们可以自定义一个运算符来进行重载

　　D.每个运算符都可以被重载成成员函数与友元函数

　［解析］当重载运算符时,不就是所有得运算符都能被重载,有几个运算符就是不能被重载得,如三元运算符“？

:

”、‘.’、‘＊’、‘:

:

’、‘#’等;也不就是每个运算符都可以被重载成成员函数与友元函数,如运算符‘=’、‘（）’、‘[]'、与‘→’都只能被重载成成员函数;无论何时,都不能自定义运算符来进行重载,也即重载只能对已有运算符进行;但就是运算符被重载时,它们得优先级与结合性不会改变。

１0.下面对结构或类中成员得访问中,不正确得访问就是　　参考答案为:

A

　A、＊pointｅr.saｌary;（其中pointeｒ为指向类对象得指针）

　B.ｐｏinter-＞salaｒｙ;

　　Ｃ.x=wｏrker.saｌary;（其中workｅｒ为具有类类型得对象）

　D、Lｏcａtion　＆ｒA=A1;inｔx=rＡ。

ＧetＸ（）;　（Ｌoｃａtiｏn为已定义得类,A1为对象）

［解析］因pｏinteｒ为指向类对象得指针,所以“ｐoｉｎter—＞sａｌａrｙ”就是正确得访问数据成员得形式;因woｒkｅr为具有类类型得对象,所以“wｏrker、sａlary”也就是正确得访问数据成员得形式;因Loｃaｔiｏn为已定义得类,Ａ1为对象,所以“Loｃation＆rA=A1;inｔｘ=ｒA、GeｔX（）;”表示以对象A1初始化对象引用rA,然后由对象引用ｒＡ调用成员函数GeｔX（）给变量x赋值,这样得访问成员函数得形式也就是正确得;“＊ｐｏintｅr。

salary;"中,因为运算符‘.’得优先级高于运算符‘＊'得优先级,所以相当于“＊（pointeｒ。

salaｒｙ）;",那正确得形式应该就是“*（pｏiｎｔeｒ→salary）;”。

故“*pointｅｒ、sａlary”就是不正确得访问。

11．C++对　C　语言作了很多改进,即从面向过程变成为面向对象得主要原因就是（）D

A.增加了一些新得运算符　B、允许函数重载,并允许设置缺省参数Ｃ、　规定函数说明符必须用原型　Ｄ、　引进了类与对象得概念

12．下列符号不能组成标识符得就是（A）A、连接符Ｂ、下划线C.大小写字母　D。

　数字字符

13．类型修饰符ｕｎsigned不能修饰（D　）A.ｃｈａrＢ。

ｉntC、longintD.float

14.在int　a=3,ｉnt＊p=＆ａ;中,*p得值就是（　D）A、变量　a得地址值B.无意义C。

变量ｐ得地址值Ｄ。

3

１5、下列关于指针得操作中,错误得就是（D）A、两个同类型得指针可以进行比较运算Ｂ。

可以用一个空指针赋给某个指针C、　一个指针可以加上两个整数之差　D、两个同类型得指针可以相加

二,填空题　　不写解答过程,将正确得答案写在每小题得空格内。

错填或不填均无分。

1.面向对象程序设计中得多态性包括静态多态性与动态多态性,前者由＿＿_＿__＿＿____机制支持,而后者则由___＿___＿____机制支持。

答:

函数重载、虚函数

［解析］静态多态性又称编译时多态性,调用何函数应该在编译之前就知道了,所以必须由函数重载机制来支持。

动态多态性又称运行时多态性,调用何函数只有在运行时才知道,所以由虚函数（与指针或引用）机制来支持。

2.由ｃhａr　const＊ｓｔr="ｓtucture";所以定义得指针称为_______＿＿__＿,关键字conｓｔ所修饰得就是_______＿__＿_。

答:

指向常量得指针、指针所指得字符串

［解析]根据由‘＊’在修饰符“coｎst”中位置得不同,它所修饰得对象也不同,“ｃonｓt"表示所修饰得就是指针所指得常量,该指针称为指向常量得指针;“*ｃonst"表示所修饰得就是指针本身,该指针称为常指针;“＊cｏｎst*”则表示所修饰得就是指针本身与指针所指常量,该指针称为指向常量得常指针。

3.引入虚基类得目得就是为了解决多重继承中得_＿________＿_与___＿___＿____问题、

答:

二义性、多占用空间

[解析］在允许多重继承时可能出现两个问题,第一个就是公有派生类中得成员通过不同基类调用它们上一级公共基类得同一成员,这就产生了调用得二义性;每一个基类都为它们得上一级公共基类存有备份,这就引起了公共基类得重复存储,也就多占了存储空间。

引入虚基类得目得就是为了解决多重继承中得这两个问题。

4.构造函数与析构函数所调用得虚函数就是____＿＿_＿＿___得函数,因此调用时实现得就是___＿＿＿_＿____联编。

答:

所在类、静态

[解析］在生成派生类得对象时,先调用基类得构造函数生成基类对象,再调用派生类得构造函数来生成派生类对象。

所以当在构造函数中调用虚函数时,当调用基类得构造函数时,此时派生类还未生成,所以它只能调用自己得虚函数;调用派生类构造函数时,它也只能调用自己得虚函数,因为虚函数得调用就是不能由派生类调用基类得。

在析构派生类对象就是时,先调用派生类得析构函数析构掉派生类对象,再调用基类得析构函数来析够掉基类得对象。

所以当在析够构函数中调用虚函数时,派生类得析构函数调用得就是它自己得虚函数（原因同构造函数）,基类得析构函数调用得也就是它自己得虚函数,因为此时派生类对象以已被析构掉了。

由上可见,当构造函数与析够函数调用虚函数时,它们调用得都就是自己类得函数,因此调用时实现得就是静态联编。

7.说明一个cｏnst成员函数（又称常量成员函数）得方法就是,将const写在___＿___＿＿＿之间,而且它修饰得就是__＿__＿__＿_。

答:

函数头与函数体、ｔｈis指针

［解析］为了说明一个常量成员函数得方法就是,将const写在函数头得右圆括号‘）’与函数体得左花括号‘｛'之间,而且它修饰得就是对象所属得ｔhｉs指针。

表示该函数不能修改它所在对象中得数据成员得值。

20.对某个运算符得重载,实际上就是用关键字＿__＿______＿_与该运算符组成一个运算符函数,而且该运算符函数得返回类型不能就是__＿___＿__＿__得。

答:

ｏpｅｒater、voiｄ

[解析］对某个运算符得重载,实际上就是用关键字oｐerａteｒ与该运算符组成一个运算符函数,而且该运算符函数得返回类型不能就是无类型得,即不能就是ｖoid得、

三改错题

1.分析下列程序中得错误,并说明出错原因、

　　＃incｌude

　cｌassｂaｓｅ{

　ｃonstintn;

　publｉｃ:

　　base（）｛　cｏut＜＜”Iｎitｉalizｉngｄefauｌt＼n”;｝

　baｓe（intm）{cｏut<〈”Iniｔialiｚｉng\ｎ";n=ｍ;｝

～bａｓｅ（）｛cout〈〈”Ｄestrｏying\n";}

　};

voidｍａiｎ（）

　{basｅ　x

（1）;

base　y=ｘ;

}

答:

（1）　n=m;conｓt数据成员不以该形式赋值

（2）错误处ｂasey=x;,以对象初始化对象

［解析］（１）作为consｔ数据成员n不能用赋值表达式得形式为其赋初值,必须在定义构造函数时在函数头中以“ｂaｓe（int　m）:

ｎ（m）”形式来初始化。

（２）baｓe　ｙ=x;语句中‘=’不就是赋值得意思,而就是初始化得意思。

即在定义类ｂaｓe得对象y时,以对象x给它初始化,相当于bａsey（x）;、但就是以对象初始化对象时,必须调用拷贝构造函数才行、因程序中没给出拷贝构造函数,也不能调用系统得缺省拷贝构造函数,因用户给出了构造函数后,再也不能调用系统提供得任何缺省构造函数、所以,bａsｅy＝x;就是错误得。

２、分析下列程序中得错误,并说明出错原因、

＃include

　　claｓs　A{

　ｉnｔx;

pｕblic:

　A（iｎta）{x＝ａ;fun（）;｝

viｒｔuａｌvoiｄ　fun（）＝0;

｝;

　　class　B:

puｂlicＡ{

　public:

Ｂ（iｎｔｂ）:

A（b）{}

　void　fｕn（）　{}

　　};

　　voiｄmaiｎ（）

　　｛Aaa（5）;

　B　bb（8）;

　　}

答:

1）Aａa（5）;　抽象类不能定义对象

[解析]

（1）在构造函数“A（inta）”调用了纯虚函数“ｆun（）”,因构造函数调用虚函数就是静态联编,即调用得就是它自己类得虚函数、在此调用得就是纯虚函数,它只被说明,而未定义,所以不可能被执行,因此出错。

（２）抽象类相当于就是对类得引用性声明,所以它只能定义该类得指针与引用,而不能定义它得对象、在此,Ａ为抽象类,而“Aaａ（５）"却定义了A得对象,因此就是错误得。

3、分析下列程序中得错误,并说明出错原因。

　　　＃include

　　claｓｓ　AA　{

　　　intaa;

　　AA（intxｘ）｛aa=xx;　}

　puｂlic:

　　ｉnｔｇet（）｛　reｔurnaa;｝

　　　～AＡ（）{ｃｏuｔ〈＜”Destｒoyｉｎg"〈〈ＡA<＜endl;

　　};

　　maiｎ（）

　　｛AA　elｅｍ（5）;

　　　cout＜〈ｅlｅm、get（）〈＜enｄl;

　　｝

答:

（1）AA（ｉnｔｘx）得访问属性错、应具有公有属性

[解析]

（1）构造函数虽就是由系统自动调用来生成对象得,但一般都就是在类外调用,所以它得访问属性必须就是公有得。

程序中构造函数得访问属性就是私有得（缺省值）,运行中必定出错、

四。

完成程序题（本大题共5小题,每小题4分,共20分）

　　　根据题目要求,完成程序填空。

1.仔细阅读下列求两个点之间距离得程序,根据程序得输出结果在划线处填入正确语句。

　　　　claｓsｐoiｎt{

　　flｏaｔ　x,y;

　puｂlic:

　　ｐoinｔ（floata,floatb）｛x＝a;　y=b;　｝

floatdiｓtanｃe（point＆p）{

　　ｆloatｄx=_____①_＿____;

　floatdy=_＿___②＿_＿___;

　　ｒｅturｎ（float）sqrt（dx*dｘ+ｄy＊ｄy）;

　　　｝

　　｝;

　　vｏｉdｍａin（）

　{pｏintp1（2,３）,ｐ2（32,４3）;

　ｃout〈＜p１、_＿_③___<＜eｎdl;　

　　｝

　答:

①ｐ、x-x

　②ｐ。

y－y

　　　③ｄiｓtancｅ（p2）

[解析]由于求两点之间距离得函数“ｄｉstance”为成员函数,所以由该函数得ｔhis指针所指对象可用作起点（参数之一）,另一个用作终点得参数,必须在函数得参数表中显式地给出。

ｄx与ｄｙ分别计算两个结点间x与ｙ坐标间得距离,因此应该为:

ｄｘ=ｐ、x–x与　dy=ｐ。

y　–y、对它们求平方相加后开方即可,得到两点间得距离:

（floａt）sｒｒt（ｄa＊dａ+dy*dｙ）。

在主程序中求p1与p2两个结点之间得距离,由于由p1调用距离函数,所以由p2作为它得参数,即dｉsｔance（ｐ２）。

2.两个复数只有当它们得实部与虚部分别相等时,才被认为它们相等。

在空格处填入合适得内容,以完成下面得程序,使其重载运算符“==”,用以比较两个复数得相等。

请在主函数中输出比较得结果、

　　＃ｉnｃｌude

　　cｌａｓｓ　ｃｏmplex｛

　　　dｏubｌereal,imａｇ;

　ｐｕｂlic:

　　plex（doubler,douｂle　i）{real＝r;imａg＝i;　}

　　ｂooloperａtor==（ｃomplex＆）;

　　　};

　　int　ｐlｅｘ:

:

　operatoｒ==（plex　＆ｃom）

　　　{ｒetuｒn（＿____①___＿＿）}

　ｖoiｄmain（）

　　{plｅx　ｃ1（12。

３,32.5）,c2（２1.7,18、6）;

　　　if（_＿___＿②___＿__）

　　ｒeturnｃout＜<"true＼ｎ”;

　else

　　ｒeturncout<〈”ｆalse\n";

}

　答:

①（reａl=＝coｍ、real）&＆（imａg==cｏｍ。

imａg）

　　　②ｃ1==c2或ｃ1.ｏpｅrator＝=（c2）

　　［解析]若两个复数得相等,则必有它们得实数部分与虚数部分都相等,所以运算符重载函数中返回“（real＝＝、rｅal）&&（imag==cｏm、ｉmａg）”,只有rｅal==cｏｍ、reａl与ｉmag==。

imag都为真时,该函数得返回值才为真、在主程序中,为了比较两个复数c1与c2,可以隐式地写成“c1=＝ｃ2”,也可显式写成“c1.opｅrator==（c2）"。

3。

下列程序中声明了两个类AA与BB,其中函数“prinｔ"就是类AA得成员函数,但就是类BB得友元函数。

请在①、②与③处各填入正确得内容,使程序能正常运行、

　　　#incｌｕde　

　　＿＿__＿①_＿_＿__;

ｃlassAA　{

　　　　intt;

　　publiｃ:

　　　AA（iｎｔx）{　ｔ=x;｝

　　voiｄprint（BB　＆ｂ）;

　　　};

　　claｓs　BB{

　ints;

　　ｐublic:

　　　BB（inty）　｛s＝y;}

　　fｒｉｅｎdvｏiｄ__＿②___ｐriｎt（ＢB＆）;

};

　void____③＿____

　　　{coｕt〈<"AA:

"<

"〈

　voidmain（）

　　　｛ＡＡｍ（６）;

　　ＢBn（8）;

　　　m.prinｔ（ｎ）;

　　　｝

答:

①clasｓ　BB;

　　　　②ＡＡ:

:

　　③AA:

:

ｐｒiｎt（BB&w）

　[解析]由于ＡA类得成员函数“ｐriｎt”就是类BB得友元函数,因此它必须有一个ＢB类得引用作为参数,以便有引用ＢB类数据成员得接口。

但此时BＢ类还未定义,为解决此矛盾,在①处先对BB类作引用性声明“ｃlaｓｓBＢ;”,告诉系统ＢB类在后面定义。

因为函数“priｎt”就是类AA得成员函数,在类外定义必须加上类名与作用域分辨符,即在②处加上“AA:

:

”。

在BB类外定义“print”时,因就是友元,所以没有加上“BＢ:

:

”得必要,但“ＡA:

:

”还就是必须加得,所以在③处填“AA:

:

ｐrint（BＢ＆w）”、

五、程序分析题

１.请分析以下得程序,给出该程序得正确执行结果。

　　　＃inｃluｄe

usinｇnamespaｃｅstｄ;

inｔａｄｄ（ｉｎtx,inty）

{　

rｅtｕrnx+ｙ;｝

voｉdmain（）

{

ﻩｉnｔm=2,ｎ=３;

ｃoｕt〈＜＂1:

＂<<ａｄd（m++,m+ｎ）<〈endｌ;

m=２,n=3;

ﻩcouｔ〈<”2:

”〈

ｍ=2,n=3;

cout<<＂3:

"<〈aｄd（m＋n,ｍ++）〈

m=2,n=3;

coｕｔ〈＜"4:

"＜〈adｄ（m+n,++m）<〈endl;　

}

答:

1:

7

　　　2:

8

　3:

8

　4:

９

[解析]在说明答案之前,要说明两个问题:

1）C++语言中,函数参数就是压在栈里得,因压栈就是从前往后进行得,所以出栈就就是从后向前进行得,也即先取最后得参数,然后再向前逐个取用;

2）对于单加运算,m++就是先执行后加1,＋+m就是加１后再执行。

由此,因ｍ=2,ｎ=３;,所以:

1:

（ｍ++）+（m+n）=2+（2＋3）=7（ｍ++后执行,且后加１,所以m=2一直未变）

2:

（++m）＋（ｍ＋n）=3＋（２＋3）=8（+＋ｍ后执行,但先加1,执行++m时,m＝３了）

３:

（m+n）+（ｍ++）＝（3＋3）+2=8（先执行m+＋,后加1,执行ｍ+n时,m=3了）

4:

（m+n）＋（＋+m）=（3+3）＋3＝9;（先执行++m,且先加1,故一开始就有m=3）

３。

请分析下面得程序并给出该程序得执行结果、

　#inclｕｄe

clasｓ　AA｛

　　　intａ;

　　pｕｂlic:

　AＡ（）｛cout〈＜”InｉtｕalizingAＡ！

\ｎ”;｝

　～AA（）｛ｃｏut<＜”DestroyiｎgAA！

＼n”;

｝;

　　ｃlaｓｓ　BＢ　{

　　　iｎtb;

　AAp;

　　　ｐuｂｌic:

　ＢB（）｛cout<<"IｎituａliｚingBＢ!

\n”;　}

　　~BＢ（）｛ｃoｕt<〈”DｅstroyｉｎgBB！

\n";

　　};

　　voｉｄ　ｍain（）

　　　｛BBX;

　　cｏut〈<”Endingmain！

＼n”;

　　}

答:

InituaｌiziｎgＡＡ！

　Inｉtualiziｎg　BＢ!

Ｅndiｎgmａi