面向对象程序设计教程马石安版.docx

面向对象程序设计教程马石安版.docx

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

面向对象程序设计教程马石安版

第1章习题答案

名词解释

抽象：

抽象（Abstract）就是忽略事物中与当前目标无关的非本质特征，而强调与当前目标有关的本质特征，从而找出事物的共性，并把具有共性的事物划为一类。

面向对象方法中的抽象，是指对具体问题（对象）进行概括，抽出一类对象的公共性质并加以描述的过程。

封装：

面向对象方法中的封装就是把将抽象出来的对象的属性和行为结合成一个独立的单位，并尽可能隐蔽对象的内部细节。

消息：

消息是面向对象程序设计用来描述对象之间通信的机制。

一个消息就是一个对象要求另一个对象实施某种操作的一个请求。

填空题

（1）面向过程的结构化程序设计方法面向对象程序设计方法

（2）顺序选择循环

（3）程序=数据结构+算法程序=对象+消息

（4）过程类

（5）抽象性封装性继承性多态性

选择题

（1）B

（2）C（3）D（4）C（5）D

（6）A（7）A（8）BC（9）AD

判断题

（1）t

（2）f（3）f（4）f（5）t（6）f（7）f（8）t

简答题

（1）

结构化程序设计方法着眼于系统要实现的功能，从系统的输入和输出出发，分析系统要做哪些事情，进而考虑如何做这些事情，自顶向下地对系统的功能进行分解，来建立系统的功能结构和相应的程序模块结构，有效地将一个较复杂的程序系统设计任务分解成许多易于控制和处理的子任务，便于开发和维护。

随着程序规模与复杂性的增长，这种面向过程的结构化程序设计方法存在明显的不足之处。

首先是数据安全性问题，由于数据被每个模块所共用，因此是不安全的，一旦出错，很难查明原因。

其次是可维护性及可重用性差，它把数据结构和算法分离为相互独立的实体，一旦数据结构需要改变时，常常要涉及整个程序，修改工作量极大并容易产生新的错误。

每一种相对于老问题的新方法都要带来额外的开销。

另外，图形用户界面的应用程序，很难用过程来描述和实现，开发和维护也都很困难。

（2）

面向对象的程序设计方法中，将程序设计为一组相互协作的对象（Object）而不是一组相互协作的函数。

在程序中，属性用数据表示，用来描述对象静态特征；行为用程序代码实现，用来描述对象动态特征。

可见，在面向对象的程序设计方法中，对象是数据结构和算法的封装体。

对象之间存在各种联系，它们之间通过消息进行通信。

程序可表示为：

程序=对象+消息

在面向对象程序设计中，它着重于类的设计。

类正是面向对象语言的基本程序模块，通过类的设计，来完成实体的建模任务。

类通过一个简单的外部接口，与外界发生关系。

一个类中的操作不会处理到另一个类中的数据，这样程序模块的独立性、数据的安全性就有了良好的保障。

程序的执行取决于事件发生的顺序，由顺序产生的消息来驱动程序的执行。

不必预先确定消息产生的顺序，更符合客观世界的实际。

并且面向对象程序设计方法提供了软件重用、解决大问题和复杂问题的有效途径，具有抽象性、封装性、继承性和多态性等特点。

（3）

结构化程序设计方法中，把数据结构和算法分离为相互独立的实体。

在面向对象程序设计中，数据结构和算法是封装在一起，结合成一个独立的单位，即对象，并尽可能隐蔽对象的内部细节。

对象的私有属性只能由这个对象的行为来读取和修改，与外部的联系通过公有行为充当外部接口。

第2章习题答案

名词解释

引用：

所谓引用，就是给对象起一个别名，使用该别名可以存取该对象。

换句话说，是使新对象和原对象共用一个地址。

内联函数：

内联函数是使用inline关键字声明一个函数。

重载函数：

重载函数通常用来对具有相似行为而数据类型不同的操作提供—个通用的名称。

填空题

（1）函数类

（2）///*……*/

（3）iostream

（4）cin>>

（5）cout<<

（6）地址值类型值

（7）&对象

（8）声明

（9）值传递引用传递

（10）inline

（11）newdelete

（12）x=10,y=10x=100,y=100

选择题

（1）A

（2）C（3）C（4）A（5）D

（6）D（7）D（8）BC（9）A（10）D

判断题

（1）t

（2）f（3）f（4）t（5）t（6）t（7）t（8）t

简答题

（1）名字空间用来防止命名的冲突。

（2）除了独立引用外，在C++程序中，引用的主要用途是用作函数参数和函数的返回值。

（3）在值传递机制中，作为实参的表达式的值被复制到由对应的形参名所标识的一个对象中，作为形参的初始值。

函数体对形参的访问、修改都是在这个标识对象上操作，与实参无关，即数据的传递是单向的。

使用引用作函数的形参时，调用函数的实参要用变量名。

实参传递给形参，相当于在被调用函数中使用了实参的别名。

于是，在被调用函数中对形参的操作，实质是对实参的直接操作，即数据的传递是双向的。

（4）内联函数是使用inline关键字声明一个函数。

在程序编译时，编译系统将程序中出现内联函数调用的地方用函数体进行替换，进而减少了时间开销。

使用内联函数应注意：

递归函数不能定义为内联函数。

内联函数一般适合于不含有switch和while等复杂的结构且只有1~5条语句的小函数，否则编译系统将该函数视为普通函数。

内联函数只能先定义后使用，否则编译系统也将该函数视为普通函数。

对内联函数也不能进行异常接口声明。

（5）不必一致。

所有的参数是根据位置和类型而不是名字来区分的。

（6）编译系统将根据函数参数的类型和个数来判断使用哪一个函数。

程序分析题（写出程序的输出结果，并分析结果）

程序的输出结果：

num=60

ref=100

程序设计题

//xiti2_1.cpp

#include

#include

usingnamespacestd;

intmain（）

{

floatx,y;

cout<<"pleaseinput2floatstox,y:

"<

cin>>x>>y;

floatz=pow（x,y）;

cout<<"pow（"<

return0;

}

第3章习题答案

填空题

（1）公有保护私有privatepubic

（2）作用域MyC1ass

（3）样板实例

（4）11

（5）1

（6）delete

（7）数据区代码区栈区堆区

（8）封装性静态成员

（9）任意访问权限许可的

（10）友元函数友元类

（11）效率

（12）friendA；

选择题

（1）B

（2）BC（3）C（4）C（5）BDB（6）C（7）B

（8）B（9）AC（10）D（11）C（12）C（13）B（14）B

（15）B（16）D（17）C（18）CD（19）D（20）A（21）A

（22）D（23）C

简答题

（1）

类实际上由一个类定义的类型称为类类型，程序员可以使用这个新类型在程序中声明新的变量，具有类类型的变量称为对象。

创建对象时，类被用作样板，对象称为类的实例。

（2）

定义类一般形式为：

class类名{

public：

<公有数据和函数>

protected：

<保护数据和函数>

private：

<私有数据和函数>

};

访问权限共有三种：

分别是公有（public）、保护（protected）和私有（private）的。

（3）

指创建类的对象。

（4）

this指针是C++为成员函数提供的一个隐含对象指针，它不能被显式声明。

this指针是一个局部量，局部于某个对象。

不同的对象调用同一个成员函数时，编译器根据this指针来确定应该引用哪一个对象的数据成员。

（5）

拷贝构造函数是一种特殊的构造函数，它的作用是用一个已经存在的对象去初始化另一个对象时。

为了保证所引用的对象不被修改，通常把引用参数声明为const参数。

在以下3种情况下，拷贝构造函数都会被自动调用：

①当用类的一个对象去初始化该类的另一个对象时。

②当函数的形参是类的对象，进行形参和实参结合时。

③当函数的返回值是类的对象，函数执行完成返回调用者时。

程序分析题

（1）

Initdefa

Initdefa

Init15

（2）

Exitmain

dst5

（3）

DefaultconstructorofPart

ConstructorofPart，3

DefaultconstructorofPart

ConstructorofWhole

DestructorofWhole

DestructorofPart，0

DestructorofPart，3

DestructorofPart，0

（4）

30

程序设计题

（1）

//xiti3_1.cpp

#include

usingnamespacestd;

classCircle

{

public:

Circle（floatr）{radius=r;}

~Circle（）{}

floatarea（）{return3.14*radius*radius;}

private:

floatradius;

};

intmain（）

{

floatr;

cout<<“请输入圆的半径：

”;

cin>>r;

Circlep（r）;

cout<<“半径为”<

”<

return0;

}

（2）

//xiti3_2.cpp

#include

usingnamespacestd;

classBook

{

public:

Book（intw）;

staticintsumnum;

staticintgetsum（）{returnsumnum;}

private:

intnum;

};

Book:

:

Book（intw）

{

num=w;

sumnum-=w;

}

intBook:

:

sumnum=120;

intmain（）

{

Bookb1（20）;

Bookb2（70）;

cout<

:

getsum（）<

return0;

}

第4章习题答案

填空题

（1）基派生

（2）单继承多继承

（3）私有继承方式

（4）公有保护

（5）多继承

（6）支配规则

（7）解决二义性

（8）使用作用域运算符引进虚基类

选择题

（1）B

（2）CD（3）ABC（4）C（5）A

（6）C（7）B（8）D（9）AD（10）A

判断题

（1）f

（2）t（3）f（4）t（5）f（6）f

简答题

（1）

面向对象技术中，类是数据和操作的集合，它们之间有3种主要关系：

Has-A，Uses-A和Is-A。

Has-A表示类的包含关系，用以描述一个类由多个“部件类”构成。

在面向对象技术中，实现has-A关系用类成员表示。

Uses-A表示一个类部分地使用另一个类。

在面向对象技术中，这种关系通过类之间成员函数的相互联系或对象参数传递实现。

另外，通过定义友员也能实现这种关系。

Is-A表示一种分类方式，描述类的抽象和层次关系。

继承可以表达is-A关系。

（2）

所谓赋值兼容规则是指在公有继承情况下，一个派生类的对象可以作为基类的对象来使用的地方。

具体来说，就是下面3种情况：

1）派生类的对象可以赋给基类的对象。

2）派生类的对象可以初始化基类的引用。

3）派生类的对象的地址可以赋给指向基类的指针。

（3）

当类的继承方式为公有继承时，在派生类中，基类的公有成员和保护成员被继承后分别作为派生类的公有成员和保护成员，这样使得派生类的成员函数可以直接访问它们，而派生类成员函数无法直接访问基类的私有成员。

在类外部，派生类的对象可以访问继承下来的基类公有成员。

当类的继承方式为私有继承时，在派生类中，基类的公有成员和保护成员作为派生类的私有成员，派生类的成员函数可以直接访问它们，而派生类的成员函数无法直接访问基类的私有成员。

在类外部，派生类的对象无法访问基类的所有成员。

当类的继承方式为保护继承时，在派生类中，基类的公有成员和保护成员作为派生类的保护成员，派生类的成员函数可以直接访问它们，而派生类的成员函数无法直接访问基类的私有成员。

在类外部，派生类的对象无法访问基类的所有成员。

（4）

首先基类构造函数被调用，子对象所在类构造函数次之，最后执行派生类构造函数。

（5）

若派生类有构造函数而基类没有，当创建派生类的对象时，派生类的相应构造函数被自动调用。

若派生类没有构造函数而基类有，则基类必须拥有缺省构造函数。

只有这样，当创建派生类的对象时，才能自动执行基类的默认构造函数。

若派生类有构造函数，且基类有缺省构造函数，则创建派生类的对象时，基类的缺省构造函数会自动执行，除非当前被调用的派生类构造函数在其初始化段中显式地调用了基类的有参构造函数。

若派生类和基类都有构造函数，但基类没有缺省构造函数，则派生类的每一个构造函数必须在其初始化列表中显式地调用基类的某个构造函数。

只有这样，当创建派生类的对象时，基类的构造函数才能获得执行机会。

程序分析题

（11,12）

（26,29）

15,16

（26,29）

程序设计题

//xiti4_1.cpp

#include

classPoint//定义基类

{

protected:

intx,y;

public:

Point（intmyx,intmyy）{x=myx;y=myy;}

voiddisplayxy（）

{

cout<<"Thepostionofpoint:

";

cout<<"（"<

}

};

classRectangle:

publicPoint//定义派生类，公有继承方式

{

private:

intl,w;

public:

Rectangle（intmyx,intmyy,intmyl,intmyw）:

Point（myx,myy）

{l=myl;w=myw;}

voiddisplaylw（）

{

cout<<"Thelengthandwidthofrectangle:

";

cout<

}

};

classCube:

publicRectangle//定义派生类，公有继承方式

{

private:

inth;

public:

Cube（intmyx,intmyy,intmyl,intmyw,intmyh）:

Rectangle（myx,myy,myl,myw）

{h=myh;}

voiddisplayh（）{cout<<"Theheightofcube:

"<

};

voidmain（）

{

Cubev（20,40,3,5,6）;//派生类对象

cout<<"Thedataofcube:

"<

v.displayxy（）;

v.displaylw（）;

v.displayh（）;

}

//第四章例题：

4.16

#include

usingnamespacestd;

classpoint

{

public:

point（intmyx,intmyy）{x=myx;y=myy;}

voiddisplayxy（）

{

cout<<"thepositionofcenter:

";

cout<<"（"<

}

protected:

intx,y;

};

classcircle:

publicpoint

{

public:

circle（intmyx,intmyy,intmyr）:

point（myx,myy）

{r=myr;}

voiddisplayr（）{cout<<"theradiusofcircle:

"<

private:

intr;

};

classcylinder:

publiccircle

{

public:

cylinder（intmyx,intmyy,intmyr,intmyh）:

circle（myx,nyy,myr）

{h=myh;}

voiddisplayh（）{cout<<"theheightofcylinder:

"<

private:

inth;

};

intmain（）

{

cylinderv（4,5,6,8）;

cout<<"thedataofcylinder:

"<

v.displayxy（）;

v.displayr（）;

v.displayh（）;

return0;

}

第5章习题答案

填空题

（1）静态动态

（2）编译时的多态性，运行时的多态性。

（3）静态动态

（4）覆盖

（5）使用了不恰当的虚函数

（6）静态

（7）0

（8）抽象类

选择题

（1）A

（1）D

（2）BD（3）B（4）AB

（5）B（6）C（7）CD（8）BD

判断题

（1）f

（2）f（3）t（4）f（5）f（6）t

简答题

（1）

多态性就是同一符号或名字在不同情况下具有不同解释的现象，即是指同一个函数的多种形态。

Ｃ＋＋支持两种多态性，编译时的多态性和运行时的多态性。

多态性有两种表现形式：

一种是不同的对象在收到相同的消息时，产生不同的动作，这主要通过虚函数来实现；另一种是同一对象收到相同的消息却产生不同的函数调用，这主要通过函数重载来实现。

（2）

重载函数只要求函数有相同的函数名，并且重载函数是在相同作用域中定义的名字相同的不同函数。

而虚函数不仅要求函数名相同，而且要求函数的签名、返回类型也相同。

也就是说函数原型必须完全相同，而且虚函数特性必定是体现在基类和派生类的类层次结构中。

重载函数可以是成员函数或友员函数，而虚函数只能是非静态成员函数。

构造函数可以重载，析构函数不能重载。

正好相反，构造函数不能定义为虚函数，析构函数能定义为虚函数。

重载函数的调用是以所传递参数序列的差别作为调用不同函数的依据而虚函数是根据对象的不同去调用不同类的虚函数。

重载函数在编译时表现出多态性，是静态联编；而虚函数则在运行时表现出多态性是动态联编，动态联编是C++的精髓。

（3）

包含有纯虚函数的类称为抽象类。

抽象类用来描述一组子类的共同的操作接口，它用作基类，而接口的完成实现由派生类提供。

抽象类的派生类不一定要给出纯虚函数的实现。

如果没有在派生类中给出纯虚函数的实现中，则需仍将它说明为纯虚函数，否则编译器将给出错误信息。

说明了纯虚函数的派生类仍是抽象类。

（4）

能声明虚析构函数。

如果一个类的析构函数是虚函数，那么，由它派生而来的所有子类的析构函数也是虚函数。

delete运算符和析构函数一起工作，当使用delete删除一个对象时，delete隐含着对析构函数的一次调用，如果析构函数为虚函数，则这个调用采用动态联编。

这样保证了基类类型的指针能够调用适当的析构函数针对不同的对象进行清理工作。

程序设计题

（2）

//xt5_2.cpp

//应用实例

#include

#include

usingnamespacestd;

classShape

{

public:

Shape（）;

voidshow（）;

virtual~Shape（）{}

virtualfloatarea（）=0;

virtualstringshapename（）=0;

protected:

stringname;

staticintcount;

};

Shape:

:

Shape（）

{

cout<<"请输入";

count=count+1;

}

voidShape:

:

show（）

{

cout<<"第"<

cout<<"，面积为"<

}

floattotal（Shape*s[],intn）

{

floatsum=0;

for（inti=0;i

{

sum+=s[i]->area（）;

deletes[i];

}

returnsum;

}

classTriangle:

publicShape

{

public:

Triangle（）;

~Triangle（）{cout<<"Triangledestructoriscalled"<

floatarea（）{returnh*w*0.5;}

stringshapename（）{name="三角形";returnname;}

protected:

floath,w;

};

Triangle:

:

Triangle（）

{

floatmyw,floatmyh;

cout<<"三角形的底和高：

";

cin>>myw>>myh;

w=myw;

h=myh;

}

classRectangle:

publicShape

{

public:

Rectangle（）;

~Rectangle（）{cout<<"Rectangledestructoriscalled"<

floatarea（）{returnl*w;}

stringshapename（）{name="矩形";returnname;}

protected:

floatl,w;

};

Rectangle:

:

Rectangle（）

{

floatmyl,floatmyw;

cout<<"矩形的长和宽：

";

cin>>myl>>myw;

l=myl;w=myw;

}

classCircle:

publicShape

{

protected:

floatradius;

public:

Circle（）;

~Circle（）{cout<<"Circledestructoriscalled"<