面向对象程序设计教程-c++语言描述-第二版-马石安

面向对象程序设计教程-c++语言描述-第二版

第1章习题答案

名词解释

抽象：抽象(Abstract)就是忽略事物中与当前目标无关的非本质特征，而强调与当前目标有关的本质特征，从而找出事物的共性，并把具有共性的事物划为一类。面向对象方法中的抽象，是指对具体问题(对象)进行概括，抽出一类对象的公共性质并加以描述的过程。

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

消息：消息是面向对象程序设计用来描述对象之间通信的机制。一个消息就是一个对象要求另一个对象实施某种操作的一个请求。

填空题

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

(2) 顺序选择循环

(3) 程序=数据结构+算法程序=对象+消息

(4) 过程类

(5) 抽象性封装性继承性多态性

选择题

(1) B (2) C (3) D (4) C (5) D

(6) A (7) A (8) B C (9) A D

判断题

(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) new delete

(12) x= 10, y=10 x= 100 , y=100

选择题

(1) A (2)C (3) C (4) A (5) D

(6) D (7) D (8) B C (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

using namespace std;

int main()

{

float x,y;

cout<<"please input 2 floats to x,y:"<

cin>>x>>y;

float z=pow(x,y);

cout<<"pow("<

return 0;

}

第3章习题答案

填空题

(1) 公有保护私有private pubic

(2) 作用域MyC1ass

(3) 样板实例

(4) 11

(5) 1

(6) delete

(7) 数据区代码区栈区堆区

(8) 封装性静态成员

(9) 任意访问权限许可的

(10) 友元函数友元类

(11) 效率

(12) friend A；

选择题

(1) B (2)BC (3) C (4)C (5) B D B (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)

Init defa

Init defa

Init 15

(2)

Exit main

dst 5

(3)

Default constructor of Part

Constructor of Part，3

Default constructor of Part

Constructor of Whole

Destructor of Whole

Destructor of Part，0

Destructor of Part，3

Destructor of Part，0

(4)

30

程序设计题

(1)

//xiti3_1.cpp

#include < iostream >

using namespace std;

class Circle

{

public:

Circle(float r){ radius = r; }

~ Circle( ) {}

float area() { return 3.14 * radius * radius; }

private:

float radius;

};

int main( )

{

float r;

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

cin >> r;

Circle p(r);

cout << “半径为”<< r << “的圆的面积为：”<< p. area () << endl; return 0;

}

(2)

//xiti3_2.cpp

#include

using namespace std;

class Book

{

public:

Book(int w);

static int sumnum;

static int getsum(){return sumnum;}

private:

int num;

};

Book::Book(int w)

{

num=w;

sumnum-=w;

}

int Book::sumnum=120;

int main()

{

Book b1(20);

Book b2(70);

cout<

return 0;

}

第4章习题答案

填空题

(1) 基派生

(2) 单继承多继承

(3) 私有继承方式

(4) 公有保护

(5) 多继承

(6) 支配规则

(7) 解决二义性

(8) 使用作用域运算符引进虚基类

选择题

(1) B (2) C D (3) A B C (4) C (5) A

(6) C (7) B (8) D (9) A D (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

class Point //定义基类

{

protected:

int x,y;

public:

Point(int myx,int myy){x=myx;y=myy;}

void displayxy()

{

cout<<"The postion of point:";

cout<<"("<

}

};

class Rectangle:public Point //定义派生类，公有继承方式

{

private:

int l,w;

public:

Rectangle(int myx,int myy,int myl,int myw):Point(myx,myy)

{l=myl;w=myw;}

void displaylw()

{

cout<<"The length and width of rectangle:";

cout<

}

};

class Cube:public Rectangle //定义派生类，公有继承方式

{

private:

int h;

public:

Cube(int myx,int myy,int myl,int myw,int myh):Rectangle(myx,myy,myl,myw)

{h=myh;}

void displayh(){cout<<"The height of cube:"<

};

void main()

{

Cube v(20,40,3,5,6); // 派生类对象

cout<<"The data of cube:"<

v.displayxy();

v.displaylw();

v.displayh();

}

// 第四章例题：4.16

#include

using namespace std;

class point

{

public:

point(int myx,int myy){x=myx;y=myy;}

void displayxy()

{

cout<<"the position of center:";

cout<<"("<

}

protected:

int x,y;

};

class circle:public point

{

public:

circle(int myx,int myy,int myr):point(myx,myy)

{r=myr;}

void displayr(){cout<<"the radius of circle:"<

private:

int r;

};

class cylinder:public circle

{

public:

cylinder(int myx,int myy,int myr,int myh):circle(myx,nyy,myr)

{h=myh;}

void displayh(){cout<<"the height of cylinder:"<

private:

int h;

};

int main()

{

cylinder v(4,5,6,8);

cout<<"the data of cylinder:"<

v.displayxy();

v.displayr();

v.displayh();

return 0;

}

第5章习题答案

填空题

(1) 静态动态

(2) 编译时的多态性，运行时的多态性。

(3) 静态动态

(4) 覆盖

(5) 使用了不恰当的虚函数

(6) 静态

(7) 0

(8) 抽象类

选择题

(1) A (1) D (2) B D (3) B (4) A B

(5) B (6) C (7) C D (8) B D

判断题

(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

using namespace std;

class Shape

{

public:

Shape();

void show();

virtual ~Shape(){}

virtual float area()=0;

virtual string shapename()=0;

protected:

string name;

static int count;

};

Shape::Shape()

{

cout<<"请输入";

count=count+1;

}

void Shape::show()

{

cout<<"第"<

cout<<"，面积为"<

}

float total(Shape *s[],int n)

{

float sum=0;

for(int i=0;i

{

sum+=s[i]->area();

delete s[i];

}

return sum;

}

class Triangle:public Shape

{

public:

Triangle();

~Triangle(){cout<<"Triangle destructor is called"<

float area(){return h*w*0.5;}

string shapename(){name="三角形";return name;} protected:

float h, w;

};

Triangle::Triangle()

{

float myw,float myh;

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

cin >>myw>>myh;

w=myw;

h=myh;

}

class Rectangle:public Shape

{

public:

Rectangle();

~Rectangle(){cout<<"Rectangle destructor is called"<

float area(){return l*w;}

string shapename(){name="矩形";return name;} protected:

float l, w;

};

Rectangle::Rectangle()

{

float myl,float myw;

cout<<"矩形的长和宽：";

cin >>myl>>myw;

l=myl;w=myw;

}

class Circle:public Shape

{

protected:

float radius;

public:

Circle();

~Circle(){cout<<"Circle destructor is called"<

float area(){return radius*radius*3.14;}

string shapename(){name="圆";return name;}

};

Circle::Circle()

{

float r;

cout<<"圆的半径：";

cin >>r;

radius=r;}

int Shape::count=0;

int main()

{

Shape *s[4];

s[0]=new Triangle();

s[0]->show();

s[1]=new Rectangle();

s[1]->show();

s[2]=new Circle();

s[2]->show();

s[3]=new Circle();

s[3]->show();

float sum=total(s,4);

cout<<"上述图形的面积和为：";

cout<

return 0;

}

第6章习题答案

填空题

(1) 函数

(2) 非静态成员函数友员函数

(3) 少

(4) 对象的引用

(5) 整型

(6) 多

选择题

(1)B (2)C (3) A (4)C

判断题

(1)t (2) f (3) t (4) f

操作题

(2) 提示：

需要声明如下形式带默认值的构造函数：

fraction(int x=0,int y=1);

需要定义一个成员函数去优化分数，如化简、不让负号在分母处等。参考代码如下：void fraction::optimization()

{

int gcd,min,max;

if(fenzi==0)

{//如分子为0，则分母为1后，返回

fenmu=1;

return;

}

gcd=(abs(fenzi)>abs(fenmu)?abs(fenmu):abs(fenzi));

if(gcd==0) return;

//以下用辗转相除法求最大公约数

if(abs(fenzi)>abs(fenmu))

{

max=fenzi;

min=fenmu;

}

else

{

min=fenzi;

max=fenmu;

}

do

{

gcd=max%min;

max=min;

min=gcd;

}while(gcd!=0);

fenzi/=max;

fenmu/=max;

if(fenzi<0&&fenmu<0)

{

fenzi=-fenzi;

fenmu=-fenmu;

}

else

if(fenzi<0&&fenmu>0)

{

fenzi=fenzi;

fenmu=fenmu;

}

else

if(fenzi>0&&fenmu>0)

{

fenzi=fenzi;

fenmu=fenmu;

}

if(fenzi>0&&fenmu<0)

{

fenzi=-fenzi;

fenmu=-fenmu;

}

}

(3) 提示：分数化简后再比较。

//第六章例题：6.3

#include

using namespace std;

class complex

{

public:

complex(double r=0.0,double i=0.0);

complex operator +(complex c);

complex operator -(complex c);

void display();

private:

double real,imag;

};

complex complex::(double )

第7章习题答案

名词解释题

函数模板：一个带类属参数的函数。

类模板：一个带类属参数的类

模板函数：通过参数实例化可以再构造出具体的函数。

模板类：通过参数实例化可以再构造出具体的类。

填空题

(1) 函数模板类模板

(2) template

(3) class typename

(4) 类属参数类似

(5) 没有

(6) 类模板

(7) 顺序容器关联容器

(8) 输入迭代器输出迭代器前向迭代器双向迭代器随机访问迭代器选择题

(1) A (2) A (3) AB (4) C (5) ABD

判断题

(1) t (2) f (3) t (4) f (5) f

程序设计题

(1)（xt7_1.cpp）

(2)（xt7_2.cpp）

第8章习题答案

填空题

(1) 流流类

(2) 标准输入

(3) cin cout cerr clog

(4) fstream.h

(5) ios类的成员函数使用控制符

(6) 顺序文件随机读写文件

(7) 输入文件流输出文件流输入/输出文件流

(8) 一个指定的文件

(9) 0

(10) read write

选择题

(1)B (2) A (3) BCD (4)C (5) A (6) C (7) AB (8) AD BC

(9)D (10) B (11)A (12) BC (13) C (14)C (15)BCD (16) C

判断题

(1) f (2) t (3)t (4)f (5) t (6) f

简答题

(1)

从流类库的基本结构可以看到，ios类是istream类和ostream类的基类，从ios类公有派生istream和ostream两个类，而iostream类通过多重继承istream类和ostream类而产生的。如果不将ios类作为其派生类的虚基类，可能会产生二义性。

(2)

在文本文件中，每个字节存放一个ASCII代码表示一个字符，文本文件的优点是可直接按字符形式输出，供人们阅读。二进制文件则是把数据的内部存储形式原样存放到文件中，这种文件的优点是与数据在内存中的存储形式保持一致，因此存储效率高，无须进行存储形式的转换，但不能直接按字符形式输出。对于那些保存中间运算结果的临时工作文件，使用二进制形式较为合理。

程序分析题

输出结果：

Hello,students!

Welcome you to oop!

程序设计题

（1）参考程序：

#include

class Fraction

{

public:

Fraction(int x=0,int y=1);

friend ostream& operator<<(ostream&,Fraction);

private:

int den; //分子

int num; //分母

};

Fraction::Fraction(int x,int y)

{

den=x;

num=y;

}

ostream& operator<<(ostream& os,Fraction fr)

{

os<

return os;

}

int main()

{

Fraction fenshu(2,3);

cout<<"fenshu= "<

return 0;

}

第9章习题答案

填空题

(1) 预料避免系统运行环境

(2) 将程序立即中断运行，从而无条件释放所有资源

(3) 不必

(4) try语句块

(5) 异常类型

(6) 任何

(7) 抛出列表

(8) 不抛出

(9)

(10) catch

选择题（至少选一个，可以多选）

(1) AC (2) B (3) D (4) CD

判断题

(1) t (2) f (3) f (4) f (5) f (6) f (7) t (8) t

简答题

(1)

异常处理是一种程序定义的错误，它对程序的逻辑错误进行设防，对运行异常加以控制。C++中，异常处理是对所能预料的运行错误进行处理的一套实现机制。

(2)

C++的异常处理机制使得异常的引发和处理不必在同一函数中。C++异常处理的目的，是在异常发生时，尽可能地减小破坏，周密地善后，而不去影响其它部分程序的运行。这样底层的函数可以着重解决具体问题，而不必过多地考虑对异常的处理。上层调用者可以在适当的位置设计对不同类型异常的处理。这在大型程序中是非常必要的。

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

运行结果：

Enter number of money:4

Enter number of glasses of milk:2

4 yuan

2 glasses of milk.

You have 2 yuan for each glass of milk. End of program.