面向对象程序设计专升本模拟题及参考答案新doc.docx
《面向对象程序设计专升本模拟题及参考答案新doc.docx》由会员分享，可在线阅读，更多相关《面向对象程序设计专升本模拟题及参考答案新doc.docx（22页珍藏版）》请在冰豆网上搜索。
面向对象程序设计专升本模拟题及参考答案新doc
东北农业大学网络教育学院
面向对象程序设计专升本作业题
作业题
（一）
1.述什么是类，并举例说明。
2.简述什么是对象，并举例说明。
3.简述C++中类的成员函数的三种访问方法。
4.阅读程序，简洁回答有关问题:
程序：
#include//
（1）
#include//
（2）
classpoint{//（3）
private:
//（4）
floatX,Y;//（5）
public:
//（6）
point（floatxi,floatyi）{X=xi,Y=yi;}//（7）
floatGetX（）{returnX}//（8）
floatGetY（）{returnY}//（9）
friendfloatdistance（point&a,point&b）;//（10）
};//（11）
voidmain（）//（12）
{
pointpl（3.5,5.5）,p2（4.5,6.5）;//（13）
floatd=distance（pl,p2）;//（14）
cout«"Thedistanceis5,«d;//（15）
}
floatdistance（point&a,point&b）//（16）
//（17）
//（18）
floatdx=a.X-b.X;
floatdy=a.Y-b.Y;
returnsqrt（dx*dx+dy*dy）;//（19）
}
问题：
1）第（10）行的作用，有什么特点？
2）如果把它改写成这个类的成员函数，应该怎样改？
4.创建一个Employee类，该类中有字符数组，表示姓名、街道地址、市、省和邮政编码。
把表示构造函数、ChangeName（）、Display（）的函数原型放在类定义中，构造函数初始化每个成员，Display。
函数把完整的对象数据打印出来。
其中的数据成员是保护的，函数是公共的。
（教材《C++程序设计教程》（钱能著）第289页第12.2题）
作业题
（二）
1.文件包含预编译指^#include那两种格式，它们有什么区别？
2.类的派生方式共有几种，基类成员权限在派生类中的权限怎样变化?
3.述面向对象程序设计方法相对于面向过程的程序设计方法的优越性。
4.阅读程序，简洁回答有关问题:
程序：
//
（1）
#include
classClock
public:
Clock（intH=0,intM=0,intS=0）
//
（2）
{Hour=H;Minute=M;Second=S;}
//（3）
Clock（Clock&c）
//⑷
{Hour=c.Hour;Minute=c.Minute;Second=c.Second;}//（5）
voidSetTime（intH=0,intM=0,intS=0）//（6）
{Hour=H;Minute=M;Second=S;}//（7）
voidShowTime（）//（8）
{cout«Hour««Minute«44:
,«Second«endl;//（9）
〜Clock。
{}//（10）
private:
intHour,Minute,Second;//（11）
}；
voidmain（void）
ClockmeClock（8,30,0）;
//（12）
MeClock.ShowTime（）;
//（13）
ClockyourClock（meClock）;
//（14）
yourClock.SetTime（）;
//（15）
yourClock.ShowTime（）;
}
问题:
1）指出Clock类的外部接口的行号。
2）指出Clock类的构造函数和拷贝构造函数以及析构函数所在行号。
3）执行那行语句时系统自动调用了构造函数并写出被初始化的对象名。
4）执行那行语句时系统调用了拷贝构造函数并写出被初始化的对象名。
写出程序的运行结果。
5.修改练习12.2种的类，将姓名构成类Name,其名和姓在该类中为保护数据成员，其构造函数为接收一个指向完整姓名字符串的指针，其Display（）函数输出姓名。
然后将Employee类中的姓名成员（字符数组）换成Name类对象。
将所有原型化的函数加上成员函数定义，作为类的内部实现文件。
构成完整的类库定义，要求类定义与类的成员函数定义分开。
（教材《C++程序设计教程》（钱能著）第289页第12.3题。
）
作业题（三）
1.简述C中结构与C++中类的区别。
2.简述C++中类的成员函数的三种访问方法。
3.简述类和对象的区别与联系并举例说明。
4.阅读程序，简洁回答有关问题:
程序：
#include
#includeclassPoint{public:
voidSet（doubleix,doubleiy）〃设置坐标
{return（180/3.14159）*atan2（y,x）;}
doubleradius（）〃取点的极坐标半径
returnsqrt（x*x+y*y）;}
protected:
doublex;
doubley;
//x轴分量
//y轴分量
};
voidmain（）
{Pointp;
doublex,y;
for（;;）{〃重复输入x和y轴分量，直到x分量值小于0
cout«"Enterxandy:
\n";
cin»x»y;
if（x<0）
break;
p.Set（x,y）;
cout«"angle="«p.angle（）
«",radius="«p.radius（）
«",xoffset二”«p.xOffset（）
«",yoffset="«p.yOffset（）«endl;
}
}
问题:
根据类的封装性，不改变该类的公有接口，不改写主函数的情况下，只改变该点类的定义与实现，要求把原有点类的私有成员X,y改写成另外两个私有数据成员a,r分别代表该点在极坐标系下的弧度值和半径值。
请写出修改后的类的定义与实现。
5.写出下面程序的运行结果，请用增加拷贝构造函数的方法避免存在的问题。
#include
classVectorj
public:
Vector（ints=100）;
int&Elem（intndx）;
voidDisplayO;
voidSet（）;
〜Vector（）;
protected:
intsize;
int*buffer;
};
Vector:
:
Vector（ints）
{
buffer=newint[size=s];
for（inti=0;i}
int&Vector:
:
Elem（intndx）
{
if（ndx<0||ndx>=size）{
cout«"errorinindex"«endl;exit（l）;
}
returnbuffer[ndx];
}
voidVector:
:
DisplayO
{
for（intj=0;jcout«buffer[j]«endl;
}
voidVector:
:
Set（）
{
for（intj=0;j}
Vector:
>Vector（）{delete[]buffer;}voidmain（）
Vectora（10）;
Vectorb（a）;
a.Set（）;
b.DisplayO;
}
教材《C++程序设计教程》（钱能著）第329页第14.2题。
作业题（四）
1.简述C++程序在内存中的分配格局。
2•简述C和C++动态内存的使用。
3•简述什么是浅拷贝和深拷贝。
4•阅读程序，简洁回答有关问题：
程序：
#include
classcomplex}private:
intreal;intimag;
public:
complex（floatr=0,floati=0）;
complexoperator+（complex&c）;
complexoperator-（complex&c）;
complexoperator-（）;voidprint（）;};
complex:
:
complex（floatr=0,floati=0）{real=r;imag=i}
complexcomplex:
:
operator+（complex&c）{
floatr=real+c.real;floati=imag+c.imag;returncomplex（r,i）;}
complexcomplex:
operator・（complex&c）{
floatr=real・c.real;floati=imag・c.imag;retumcomplex（r,i）;}
complexoperator-（）{returncomplex（-real,-img）;}
voidcomplex:
:
print（）{cout«"（"«real«","«imag«"）"«endl;}
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重新编写下述程序，使函数Leisure。
成为类Car和类Boat的函数。
作为重新变成，在类Car和类Boat中，增加函数get（）
#include
classBoat;
classCar{
public:
Car（intj）{size=j;}
FriendintLeisure（inttime,car&aobj,Boat&bobj）;
Protected:
intsize;
}；
intLeisure（inttime,Car&aobj,Boat&bobj）
{
returntime*aobj.size*bobj.size;
voidmain（）
Carcl
（2）;
Boatbl（3）;
inttime=4;
cout«Leisure（time,c1,b1）;
}
教材《C++程序设计教程》（钱能著）第348页第15.3题。
作业题（五）
1.简述静态成员函数与一般成员函数的主要差别。
2.简述什么是先期联编，什么是迟后联编。
3.简述多继承中构造函数被调用顺序。
4•阅读程序，简洁回答有关问题：
下列shape类是一个表示形状的抽象类，area（）为求图形面积的函数，total（）则是一个通用的用以求不同形状的图形面积总和的函数。
请从shape类派生梯形类（trapezoid）、圆形类（circle）,并给出具体的求面积函数
classshape{
public:
virtualfloatarea（）二0
}；
floattotal（shape*s[],irrtn）
{
floatsum=0.0;
for（inti=0;i〈n;i++）
sum+=s[i]->area（）;
returnsum;
5.根据16.12（类的分解）节中所定义的Account类、Savings类和Checking类，编写一个应用程序，它取出一系列账号的存款，直到碰到一个标志结束的符号。
要求程序用多态的方法实现，并输出取出的账号和金额数。
（教材《C++程序设计教程》（钱能著）第380页第16.2题。
）
东北农业大学网络教育学院
面向对象程序设计作业题参考答案
作业题一参考答案
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.h1'
#include
Employee:
:
Employee（char*n,char*a,char*c,char*s,char*z）{
strncpy（name,n,20）;
name[19]-\0';
stmcpy（addr,a,40）;
addr[39]='\0‘；
strncpy（city,c,20）;
city[19]=W;
stmcpy（state,s,20）;
state[19]='\0';
stmcpy（zip,z,10）;
zip[9]m\0：
}
voidEmployee:
:
ChangeName（char*n）
{
stmcpy（name,n,20）;
name[19]=,\0,;
voidEmployee:
:
Display（）
{
cout«name«endl
«addr«""«city«endl
«state«""
«zip«endl;
}
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:
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«firstName«""«lastName«endl;
}
voidName:
:
ChangeName（char*n）
{
char*p=n;
inti;
for（i=0;i<19;i++）{
if（*p=‘,||*p==,\0,）
break;
firstName[i]=*p++;
}
firstName[i]='\O';
if（*p==,\O,）{
lastName[0]='\0';
return;
}
while（*p==''）p++;
for（i=0;i<19;i++）{
if（*p=，]|*p=、（y）
break;
lastName[i]=*p++;
}
lastName[i]=,\O,;
}
Employ:
:
Employ（char*n,char*a,char*c,char*s,char*z）:
name（n）
{
stmcpy（addr,a,40）;
addr[39]=,\0,;
stmcpy（city,c,20）;
city[19]=,\0,;
stmcpy（state,s,20）;
state[19]='\0';
stmcpy（zip,z,10）;
zip[9]=、0：
}
voidEmploy:
:
ChangeName（char*n）
{
name.ChangeName（n）;
}
voidEmploy:
:
Display（）
{
name.DisplayO;
cout«addr«""«city«endl
«state«"”
«zip«endl;
}
作业题三参考答案
1.答：
C中结构只含数据成员，不含成员函数；
C++中类即含数据成员，又含成员函数.
类定义中默认情况下的成员是private的，
而结构定义中的默认情况下的成员是public的.
2.答：
假设有如下类
classTdate{public:
voidSet（int,int,int）;intIsLeapYear（）;voidPrint（）;
private:
intmonth;intday;intyear;};
IT.运算符”直接访问：
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;
doub
升级会员 