面向对象程序设计作业题参考答案.docx

资源描述

面向对象程序设计作业题参考答案.docx

《面向对象程序设计作业题参考答案.docx》由会员分享，可在线阅读，更多相关《面向对象程序设计作业题参考答案.docx（19页珍藏版）》请在冰点文库上搜索。

面向对象程序设计作业题参考答案.docx

面向对象程序设计作业题参考答案

东北农业大学网络教育学院

面向对象程序设计作业题参考答案

作业题一答案

1.答:

类实际上是对某种类型的对象定义变量和方法的原型。

我们可以利用相同种类的对象是相似的事实来为这些对象创建一个蓝图。

对对象的软件蓝图叫做类。

就象自行车制造商人，自行车的类需要定义一些实例变量来包括当前档位、当前速度等等。

这个类需要定义实例方法来提供实施方法，如允许骑车者改变档位、刹车以及改变脚踏板的节奏等。

2.答：

对象是一些相关的变量和方法的软件集。

软件对象经常用于模仿现实世界中我们身边的一些真实对象。

对象是理解面向对象技术的关键。

你可以发现现实世界中的对象有两个共同特征：

它们都有状态和行为。

比如某条狗有自己的状态（比如名字、颜色、生育以及饥饿等等）和行为（比如摇尾巴等等）。

同样某辆自行车也有自己的状态（比如当前档位、两个轮子等等）和行为（比如刹车、加速、减速以及改变档位等等）。

3．答：

假设有如下类

classTdate{public:

voidSet（int,int,int）;intIsLeapYear（）;voidPrint（）;

private:

intmonth;intday;intyear;};

//”.运算符”直接访问：

Tdateoneday;oneday.Set（2,15,1998）;

//通过指针访问:

Tdateoneday;Tdate*sptr;sptr=&oneday;sptr->Set（2,15,1998）;

//通过引用访问:

Tdateoneday;Tdate&srel=oneday;srel.Set（2,15,1998）;

4．答：

这是个类的友元函数，不属于这个类，但可以访问该类的所有成员，无论这个成员是私有的还是共有的。

（10）行，去掉关键字friend；

（16）行及其后，改为

floatpoint:

distance（point&a）{

floatdx=X–a.X;

floatdy=Y–b.Y;

returnsqrt（dx*dx+dy*dy）;

}

5．参考程序

//employee.h

#ifndefEMPLOYEE

#defineEMPLOYEE

classEmployee{

public:

Employee（char*n,char*a,char*c,char*s,char*z）;

voidChangeName（char*n）;

voidDisplay（）;

protected:

charname[20];

charaddr[40];

charcity[20];

charstate[20];

charzip[10];

};

#endif

//employee.cpp

#include"employee.h"

#include

Employee:

Employee（char*n,char*a,char*c,char*s,char*z）

{

strncpy（name,n,20）;

name[19]='\0';

strncpy（addr,a,40）;

addr[39]='\0';

strncpy（city,c,20）;

city[19]='\0';

strncpy（state,s,20）;

state[19]='\0';

strncpy（zip,z,10）;

zip[9]='\0';

}

voidEmployee:

ChangeName（char*n）

{

strncpy（name,n,20）;

name[19]='\0';

}

voidEmployee:

Display（）

{

cout<

}

charname[20];

charaddr[40];

charcity[20];

charstate[20];

charzip[10];

作业题二答案

1．答：

#include<文件名.扩展名>#include“文件名.扩展名”两种格式。

第一种：

编译器根据目录出现的顺序分别查找各路径。

第二种：

编译器首先在当前目录中查找，然后象前一种方式那样在标准路径下查找。

2．答：

分共有派生、私有派生和保护派生。

共有派生中publicprotected权限不变,private

变inaccessible.私有派生中public变private,protectedprivate变inaccessible.

保护派生中publicprotected变protected,private变inaccessible.

3.答:

面向过程的程序设计方法的基本思想是：

功能分解、逐步求精。

当一些任务十分复杂以至无法描述时，可以将它拆分为一系列较小的功能部件，直到这些自完备的子任务小到易于理解的程度。

结构化程序设计成功地为处理复杂问题提供了有力的手段。

但是当数据量增大时，数据与处理这些数据的方法之间的分离使程序变得越来越难以理解。

而且对数据处理能力的需求越强，这种分离所造成的负作用越显著。

面向对象程序设计的本质是把数据和处理数据的过程当成一个整体——对象。

面向对象程序设计的实现了封装和数据隐藏技术，继承和多态性。

使得我可以直接映射问题空间，映射现实世界的层次结构（抽象概念和客观事物等），是程序更易编写和维护，代码的可复用性更强。

4．答：

（2）---（10）

（2），（4），（10）

（12）,meClock

（14），yourClock

30:

0000:

00:

5．参考程序

//employ.h

#ifndefEMPLOY

#defineEMPLOY

className{

public:

Name（char*n）;

voidDisplay（）;

voidChangeName（char*n）;

protected:

charfirstName[20];

charlastName[20];

};

classEmploy{

public:

Employ（char*n,char*a,char*c,char*s,char*z）;

voidChangeName（char*n）;

voidDisplay（）;

protected:

Namename;

charaddr[40];

charcity[20];

charstate[20];

charzip[10];

};

#endif

//employ.cpp

#include

#include"employ.h"

Name:

Name（char*n）

{

ChangeName（n）;

}

voidName:

Display（）

{

cout<

}

voidName:

ChangeName（char*n）

{

char*p=n;

inti;

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

if（*p==''||*p=='\0'）

break;

firstName[i]=*p++;

}

firstName[i]='\0';

if（*p=='\0'）{

lastName[0]='\0';

return;

}

while（*p==''）p++;

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

if（*p==''||*p=='\0'）

break;

lastName[i]=*p++;

}

lastName[i]='\0';

}

Employ:

Employ（char*n,char*a,char*c,char*s,char*z）:

name（n）

{

strncpy（addr,a,40）;

addr[39]='\0';

strncpy（city,c,20）;

city[19]='\0';

strncpy（state,s,20）;

state[19]='\0';

strncpy（zip,z,10）;

zip[9]='\0';

}

voidEmploy:

ChangeName（char*n）

{

name.ChangeName（n）;

}

voidEmploy:

Display（）

{

name.Display（）;

cout<

}

作业题三答案

1．答：

C中结构只含数据成员,不含成员函数;

C++中类即含数据成员,又含成员函数.

类定义中默认情况下的成员是private的,

而结构定义中的默认情况下的成员是public的.

2．答：

假设有如下类

classTdate{public:

voidSet（int,int,int）;intIsLeapYear（）;voidPrint（）;

private:

intmonth;intday;intyear;};

//”.运算符”直接访问：

Tdateoneday;oneday.Set（2,15,1998）;

//通过指针访问:

Tdateoneday;Tdate*sptr;sptr=&oneday;sptr->Set（2,15,1998）;

//通过引用访问:

Tdateoneday;Tdate&srel=oneday;srel.Set（2,15,1998）;

3．答：

类用来描述一类事物,描述这些事物所应具有的属性。

类的实例化，即对象。

一个类可以有无数个对象。

对象可以被创建和销毁，但类是无所不在的。

例如：

人是类，你、我、他都是类的实例。

桌子是类，具体的桌子是类的实例。

4．答：

#include

classPoint{

public:

voidSet（doubleix,doubleiy）

{a=atan2（iy,ix）;//接口

r=sqrt（ix*ix+iy*iy;}

doublexOffset（）//接口

{returnr*cos（a）;}

doubleyOffset（）//接口

{returnr*sin（a）;}

doubleangle（）//接口

{return（180/3.14159）*a;}

doubleradius（）//接口

{returnr;}

protected:

doublea;

doubler;};

5．参考程序

#include

classVector{

public:

Vector（ints=100）;

Vector（constVector&v）;

int&Elem（intndx）;

voidDisplay（）;

voidSet（）;

~Vector（）;

protected:

intsize;

int*buffer;

};

Vector:

Vector（ints）

{

buffer=newint[size=s];

for（inti=0;i

buffer[i]=i*i;

}

Vector:

Vector（constVector&v）:

size（v.size）

{

buffer=newint[size];

for（inti=0;i

buffer[i]=v.buffer[i];

}

int&Vector:

Elem（intndx）

{

if（ndx<0||ndx>=size）{

cout<<"errorinindex"<

exit

（1）;

}

returnbuffer[ndx];

}

voidVector:

Display（）

{

for（intj=0;j

cout<

}

voidVector:

Set（）

{

for（intj=0;j

buffer[j]=j+1;

}

Vector:

~Vector（）{delete[]buffer;}

voidmain（）

{

Vectora（10）;

Vectorb（a）;

a.Set（）;

b.Display（）;

}

//运行结果为：

//增加拷贝构造函数后的运行结果为：

作业题四答案

1．答：

C++程序的内存格局通常分为四个区：

*全局数据区（dataarea）

*代码区（codearea）

*栈区（stackarea）

*堆区（heaparea）

全局变量、静态数据、常量存放在全局数据区，所有类成员函数和非成员函数存放在代码区，为运行函数而分配的局部变量、函数参数、返回数据、返回地址等存放在栈区，余下的空间被作为堆区。

2．答：

在C语言中，获得和释放内存的函数是：

void*malloc（size_tsize）;//size_t即unsignedlong

voidfree（void*）;//这两个函数在alloc.h头文件中声明.

在C++语言中，获得和释放内存的操作符是：

new和delete//它们不用头文件声明,可以带初始

值表和单元个数.

malloc（）函数只负责分配指定大小的空间，而不知这块空间用来存放什么类型的变量；而new不但知道要分配空间的大小，还知道待分配对象的数据类型是什么，因此，如果分配的空间给指定类的对象实例，它能够自动调用该类的构造函数初始化该对象。

3．答：

在默认的拷贝构造函数中，拷贝的策略是逐个成员依次拷贝，这种被称为浅拷贝。

但是，一个类可能拥有资源，当其构造函数分配了一个资源（例如某个堆内存地址）的时候，会发生什么？

如果拷贝构造函数简单地制作了一个该资源的引用的拷贝，而不对它本身分配，就得面临一个麻烦的局面：

两个对象都拥有同一个资源。

当对象析构时，该资源将经历两次资源返还。

这个时候，我们在执行拷贝时，最好同时对资源本身进行复制，这种拷贝方法，我们称之为深拷贝。

4．答：

#include

classcomplex{private:

floatreal;floatimag;

public:

complex（floatr=0,floati=0）;voidprint（）;

friendcomplexoperator+（complex&c1,complex&c2）;

friendcomplexoperator-（complex&c1,complex&c2）;

friendcomplexoperator-（complex&c）;};

complex:

complex（floatr=0,floati=0）{real=r;imag=i}

complexcomplex:

operator+（complex&c1,complex&c2）{

floatr=c1.real+c2.real;floati=c1.imag+c2.imag;returncomplex（r,i）;}

complexcomplex:

operator-（complex&c1,complex&c2）{

floatr=c1.real-c2.real;floati=c1.imag-c2.imag;returncomplex（r,i）;}

complexoperator-（complex&c）{returncomplex（-c.real,-c.img）;}

voidcomplex:

print（）{cout<<"（"<

voidmain（）{complexx（2.5,3.8）,y（4.7,5.4）,z;

z=x+y;z.print（）;z=x-y;z.print（）;z=-x;z.print（）;}

5．参考程序

#include

classBoat;

classCar{

public:

Car（intj）{size=j;}

intGet（）{returnsize;}

protected:

intsize;

};

classBoat{

public:

Boat（intj）{size=j;}

intGet（）{returnsize;}

protected:

intsize;

};

intLeisure（inttime,Car&aobj,Boat&bobj）

{

returntime*aobj.Get（）*bobj.Get（）;

}

voidmain（）

{

Carc1

（2）;

Boatb1（3）;

inttime=4;

cout<

}

作业题五答案

1．答：

一个静态成员函数不与任何对象相联系，故不能对非静态成员进行默认的访问。

一个静态成员函数与非静态成员函数的根本区别在于，静态成员函数没有this指针，而非静态成员函数有一个指向当前对象的指针this。

例如:

classSc{public:

voidnsfn（inta）;

staticvoidsfn（inta）;//…}

voidf（Sc&s）{s.nsfn（10）;//转化为Sc:

nsfn（&s,10）

s.sfn（10）;//转化为Sc:

sfn（10）}

2．答：

编译时就能确定哪个重载函数被调用的,称为先期联编。

而在运行时，才能确认调用那个重载函数，称为迟后联编（滞后联编）。

C++中继承机制中用多态性的技术来实现迟后联编。

为指明某个成员函数具有多态性，用关键字virtual来标志其为虚函数。

3．答：

构造函数按照下列的顺序被调用:

1.任何虚拟基类的构造函数按照它们被继承的顺序构造.

2.任何非虚拟基类的构造函数按照它们被继承的顺序构造.

3.任何成员函数的构造函数按照它们声明的顺序调用.

4.类自己的构造函数.

4．答：

classCircle:

publicShape

　{

　public:

　　Circle（doubler）{radius=r;}

　　doubleArea（）const{return3.1416*radius*radius;}

　private:

　　doubleradius;

　};

　classTrapezoid:

publicShape

　{

　public:

　　Trapezoid（doubletop,doublebottom,doublehigh）

　　{T=top;B=bottom;H=high;}

　　doubleArea（）const{return（T+B）*H*0.5;}

　private:

　　doubleT,B,H;

　};

5．参考程序

#include

#include"account.h"

#include"savings.h"

#include"checking.h"

voidmain（）

{

unsignedaN;

floatval;

cout<<"pleaseinputsomeaccountandsavings:

\n";

cin>>aN>>val;

while（aN）{

newSavings（aN,val）;

cout<<"pleaseinputsomeaccountandsavings:

\n";

cin>>aN>>val;

}

cout<<"pleaseinputsomeaccountandchecking:

\n";

cin>>aN>>val;

while（aN）{

newChecking（aN,val）;

cout<<"pleaseinputsomeaccountandchecking:

\n";

cin>>aN>>val;

}

for（Account*p=Account:

First（）;p;p=p->Next（））

cout<AccountNo（）<<""<AcntBalan（）<

for（Account*p=Account:

First（）;p;）{

Account*t=p;

p=p->Next（）;

deletet;

}

Account:

First（）=NULL;

}

展开阅读全文