《面向对象程序设计c》综合复习题集及答案详解.docx
《《面向对象程序设计c》综合复习题集及答案详解.docx》由会员分享，可在线阅读，更多相关《《面向对象程序设计c》综合复习题集及答案详解.docx（77页珍藏版）》请在冰豆网上搜索。
《面向对象程序设计c》综合复习题集及答案详解
《面向对象程序设计》
综
合
复
习
题
集
四、程序填充
1.斐波那契数列的第1和第2个数分别为0和1，从第三个数开始，每个数等于其前两个数之和。
求斐波那契数列中的前20个数，要求每行输出5个数。
#include
voidmain（）{
intf,f1,f2,i;
cout<<”斐波那契数列：
\n”;
f1=0;f2=1;
cout<for（i=3;i<=20;i++）{
f=______
（1）______;
cout<if（_____
（2）______）cout<f1=f2;
f2=____（3）_______;
}
cout<}
（1）
（2）（3）
2.计算
的值。
#include
voidmain（）
{
doublex,p1=1,p2=1,s=0;
inti,j=1;
cout<<"输入x的值:
";
cin>>x;
for（i=1;i<=10;i++）{
p1*=___
（1）_____;
p2*=____
（2）____;
s+=j*p1/p2;//j的值为（-1）i+1
j=____（3）____;
}
cout<}
（1）
（2）（3）
17.假定有定义为“structNODE{intdata;NODE*next;};”，下面算法根据table数组中的n个元素建立一个表头指针为L的链表，链表中结点值的顺序与数组元素值的顺序相同。
voidf5（NODE*&L,inttable[],intn）
{
if（n<=0）{L=NULL;return;}
L=newNODE;//生成附加的头结点
inti=0;
NODE*p=L;
while（___
（1）___）{
p=p->next=___
（2）___;
p->data=___（3）___;
i++;
}
p->next=NULL;//把最后一个结点的指针域置空
p=L;
L=L->next;//使L指向链表的第一个带值的结点
deletep;
}
（1）
（2）（3）
22.已知一维数组类ARRAY的定义如下，构造函数的作用是把参数n的值赋给s，给v动态分配长度为n的数组空间，接着利用数组参数a初始化v所指向的数组。
classARRAY{
int*v;//指向存放数组数据的空间
ints;//数组大小
public:
ARRAY（inta[],intn）;
~ARRAY（）{delete[]v;}
intsize（）{returns;}
int&operator[]（intn）;
};
___
（1）___ARRAY（inta[],intn）
{
if（n<=0）{v=NULL;s=0;return;}
s=n;
v=___
（2）___;
for（inti=0;i}
（1）
（2）（3）
24.已知一个类的定义如下：
#include
classAA{
inta[10];
intn;
public:
voidSetA（intaa[],intnn）;//用数组aa初始化数据成员a，
//用nn初始化数据成员n
intMaxA（）;//从数组a中前n个元素中查找最大值
voidSortA（）;//采用选择排序的方法对数组a中前n个元素
//进行从小到大排序
voidInsertA（）;//采用插入排序的方法对数组a中前n个元素进行从小到大排序
voidPrintA（）;//依次输出数组a中的前n个元素
};
该类中MaxA（）函数的实现如下，请在标号位置补充适当的内容。
int____
（1）_____
{
intx=a[0];
for（inti=1;iif（a[i]>x）___
（2）___;
___（3）___;
}
（1）
（2）（3）
25.已知一个类的定义如下：
#include
classAA{
inta[10];
intn;
public:
voidSetA（intaa[],intnn）;//用数组aa初始化数据成员a，
//用nn初始化数据成员n
intMaxA（）;//从数组a中前n个元素中查找最大值
voidSortA（）;//采用选择排序的方法对数组a中前n个元素
//进行从小到大排序
voidInsertA（）;//采用插入排序的方法对数组a中前n个元素进行从小到大排序
voidPrintA（）;//依次输出数组a中的前n个元素
};
voidAA:
:
SortA（）
{
inti,j;
for（i=0;___
（1）___;i++）{
intx=a[i],k=i;
for（j=i+1;jif（a[j]（2）___
a[k]=a[i];
___（3）___;
}
}
（1）
（2）（3）
26.已知一个类的定义如下：
#include
classAA{
inta[10];
intn;
public:
voidSetA（intaa[],intnn）;//用数组aa初始化数据成员a，
//用nn初始化数据成员n
intMaxA（）;//从数组a中前n个元素中查找最大值
voidSortA（）;//采用选择排序的方法对数组a中前n个元素
//进行从小到大排序
voidInsertA（）;//采用插入排序的方法对数组a中前n个元素进行从小到大排序
voidPrintA（）;//依次输出数组a中的前n个元素
};
void___
（1）___
{
inti,j;
for（i=1;iintx=a[i];
for（j=i-1;j>=0;j--）
if（x（2）___;
else___（3）___;
a[j+1]=x;
}
}
（1）
（2）（3）
27.已知一个类的定义如下：
#include
classAA{
inta[10];
intn;
public:
voidSetA（intaa[],intnn）;//用数组aa初始化数据成员a，
//用nn初始化数据成员n
intMaxA（）;//从数组a中前n个元素中查找最大值
voidSortA（）;//采用选择排序的方法对数组a中前n个元素
//进行从小到大排序
voidInsertA（）;//采用插入排序的方法对数组a中前n个元素进行从小到大排序
voidPrintA（）;//依次输出数组a中的前n个元素
//最后输出一个换行
};
使用该类的主函数如下：
voidmain（）
{
inta[10]={23,78,46,55,62,76,90,25,38,42};
AAx;
___
（1）___;
intm=___
（2）___;
___（3）___;
cout<}
该程序运行结果为:
237846556276
78
（1）
（2）（3）
28.已知一个类的定义如下：
#include
classAA{
inta[10];
intn;
public:
voidSetA（intaa[],intnn）;//用数组aa初始化数据成员a，
//用nn初始化数据成员n
intMaxA（）;//从数组a中前n个元素中查找最大值
voidSortA（）;//采用选择排序的方法对数组a中前n个元素
//进行从小到大排序
voidPrintA（）;//依次输出数组a中的前n个元素，
//最后输出一个换行
};
使用该类的主函数如下：
voidmain（）
{
inta[10]={23,78,46,55,62,76,90,25,38,42};
___
（1）___;
x.SetA（a,8）;
int___
（2）___;
___（3）___;
x.PrintA（）;
cout<}
该程序运行结果为:
2325465562767890
90
（1）
（2）（3）
29.已知一个利用数组实现栈的类定义如下：
constintARRAY_SIZE=10;
classStack{
public:
voidInit（）{top=-1;}//初始化栈为空
voidPush（intnewElem）;//向栈中压入一个元素
intPop（）;//从栈顶弹出一个元素
boolEmpty（）{//判栈空
if（top==-1）returntrue;elsereturnfalse;}
intDepth（）{returntop+1;}//返回栈的深度
voidPrint（）;
//按照后进先出原则依次输出栈中每个元素，直到栈空为止
private:
intelem[ARRAY_SIZE];//用于保存栈元素的数组
inttop;//指明栈顶元素位置的指针
};
voidStack:
:
Push（intnewElem）{
if（___
（1）___）{
cout<<"栈满!
"<exit
（1）;//中止运行
}
___
（2）___;
elem[top]=___（3）___;
}
（1）
（2）（3）
30.已知一个利用数组实现栈的类定义如下：
constintARRAY_SIZE=10;
classStack{
public:
voidInit（）{top=-1;}//初始化栈为空
voidPush（intnewElem）;//向栈中压入一个元素
intPop（）;//从栈顶弹出一个元素
boolEmpty（）{//判栈空
if（top==-1）returntrue;elsereturnfalse;}
intDepth（）{returntop+1;}//返回栈的深度
voidPrint（）;
//按照后进先出原则依次输出栈中每个元素，直到栈空为止
private:
intelem[ARRAY_SIZE];//用于保存堆栈元素的数组
inttop;//指明栈顶元素位置的指针
};
该类的Pop和Print函数的实现分别如下：
___
（1）___{
if（top==-1）{
cout<<"栈空!
"<exit
（1）;//中止运行
}
return___
（2）___;
}
voidStack:
:
Print（）{
while（!
Empty（））
cout<<___（3）___<<'';
}
（1）
（2）（3）
31．classA{
inta;
public:
A（）{a=0;}
___
（1）___{}//定义构造函数，用参数aa初始化数据成员a
};
main（）{
___
（2）___;//定义类A的指针对象p
___（3）__;//用p指向动态对象并初始化为整数5
}
（1）
（2）（3）
32．classA{
char*a;
public:
___
（1）___//定义无参构造函数，使a的值为空
A（char*aa）{
a=___
（2）___;
strcpy（a,aa）;//用aa所指字符串初始化a所指向的动态存储空间
}
___（3）___//定义析构函数，删除a所指向的动态存储空间
};
（1）
（2）（3）
33．classA{
inta,b;
public:
A（intaa=0,intbb=0）___
（1）___{}//分别用aa和bb对应初始化a和b
};
main（）{
___
（2）___;//定义类A的对象x并用5初始化，同时定义y并用x初始化
___（3）___;//定义p指针，使之指向对象x
}
（1）
（2）（3）
34．classA{
inta,b;
public:
___
（1）___//定义构造函数，使参数aa和bb的默认值为0，
//在函数体中用aa初始化a，用bb初始化b
};
main（）{
A*p1,*p2;
___
（2）___;//调用无参构造函数生成由p1指向的动态对象
___（3）___;//调用带参构造函数生成由p2指向的动态对象，
//使a和b成员分别被初始化为4和5
}
（1）
（2）（3）
35.#include
#include
classA{
int*a;intn;intMaxLen;
public:
A（）:
a（0）,n（0）,MaxLen（0）{}
A（int*aa,intnn,intMM）{
n=nn;
MaxLen=MM;
if（n>MaxLen）exit
（1）;
___
（1）___;//由a指向长度为MaxLen的动态数组
for（inti=0;i}
~A（）{delete[]a;}
intGetValue（inti）___
（2）___//函数体返回a[i]的值
};
voidmain（）
{
intb[10]={1,2,3,4,5,6,7,8,9,10};
Ar（b,10,10）;
inti,s=0;
for（i=0;i<10;i++）;___（3）___//把r对象的a数据成员中的每个
//元素值依次累加到s中
cout<<"s="<}
（1）
（2）（3）
36.#include
#include
classA{
int*a;intn;intMaxLen;
public:
A（）:
a（0）,n（0）,MaxLen（0）{}
A（int*aa,intnn,intMM）{
n=nn;
MaxLen=MM;
if（n>MaxLen）exit
（1）;
a=newint[MaxLen];
___
（1）___;//以i为循环变量把aa数组中每个元素值
//传送给a数组的对应元素中
}
~A（）;
intGetValue（inti）{returna[i];}//函数体返回a[i]的值
};
___
（2）___//析构函数的类外定义
voidmain（）
{
intb[10]={1,2,3,4,5,6,7,8,9,10};
Ar（b,10,10）;
inti,s=0;
___（3）___;//以i为循环变量，把r对象的a数据成员中的
//每个元素值依次累加到s中
cout<<"s="<}
（1）
（2）（3）
37.一种类定义如下:
classGoods
{
private:
chargd_name[20];//商品名称
intweight;//商品重量
staticinttotalweight;//同类商品总重量
public:
Goods（char*str,intw）{//构造函数
strcpy（gd_name,str）;
weight=w;
totalweight+=weight;
}
~Goods（）{totalweight-=weight;}
char*GetN（）{___
（1）___;}//返回商品名称
intGetW（）{returnweight;}
___
（2）___GetTotal_Weight（）{//定义静态成员函数返回总重量
___（3）___;
}
}
（1）
（2）（3）
38.
classPoint
{
private:
intx,y;
public:
Point（）{x=y=0;}
Point（intx0,inty0）{x=x0;y=y0;}
intGetX（）{returnx;}
intGetY（）{returny;}
voidPrint（）{cout<<"Point（"<___
（1）___;//友元函数声明
___
（2）___;//友元函数声明
};
Pointoperator+（Point&pt,intdd）
//加号操作符重载函数，实现Point类对象与整数加法
{
Pointtemp=pt;
temp.x+=dd;
temp.y+=dd;
returntemp;
}
Pointoperator+（Point&pt1,Point&pt2）
//加号操作符重载函数，实现两个Point类对象的加法
{
Pointtemp=pt1;
temp.x+=pt2.x;
___（3）___;
returntemp;
}
（1）
（2）（3）
39.在下面一段类定义中，Derived类是由直接基类Base1和Base2所派生的，Derived类包含有两个间接基类BaseBase，在初始化函数Init中，需要把x1和x2的值分别赋给属于基类Base1的x成员和属于基类Base2的x成员。
classBaseBase{
protected:
intx;
public:
BaseBase（）{x=1;}
};
classBase1:
publicBaseBase{
public:
Base1（）{}
};
classBase2:
publicBaseBase{
public:
Base2（）{}
};
classDerived:
___
（1）___
{
public:
Derived（）{}
voidInit（intx1,intx2）{
___
（2）___;___（3）___;
}
voidoutput（）{cout<:
x<<''<:
x<};
（1）
（2）（3）
40.在下面一段类定义中，Derived类公有继承了基类Base。
需要填充的函数由注释内容给出了功能。
classBase
{
private:
intmem1,mem2;//基类的数据成员
public:
Base（intm1,intm2）{
mem1=m1;mem2=m2;
}
voidoutput（）{cout<//...
};
classDerived:
publicBase
{
private:
intmem3;//派生类本身的数据成员
public:
//构造函数,由m1和m2分别初始化mem1和mem2，由m3初始化mem3
Derived（intm1,intm2,intm3）;
//输出mem1,mem2和mem3数据成员的值
voidoutput（）{
___
（1）___;cout<}
//...
};
Derived:
:
Derived（intm1,intm2,intm3）:
___
（2）___{___（3）___;}
（1）
（2）（3）
41.在下面一段类的定义中，需要填充的函数由注释内容给出了功能。
classPoint//定义坐标点类
{
public:
intx,y;//点的横坐标和纵坐标
Point（）{x=0;y=0;}
Point（intx0,inty0）{x=x0;y=y0;}
intX（）{returnx;}
intY（）{returny;}
voidPrintP（）{cout<<"Point:
（"<};
classLine:
publicPoint//利用坐标点类定义直线类
{
private:
classPointpt1,pt2;//直线的两个端点
public:
Line（Pointpts,Pointpte）;//构造函数，分别用参数初始化对应的端点
doubleDx（）{returnpt2.x-pt1.x;}
doubleDy（）{returnpt2.y-pt1.y;}
doubleLength（）{//计算直线的长度
returnsqrt（___
（1）___）;
};
voidPrintL（）;//输出直线的两个端点和直线长度
};
Line:
:
Line（Pointpts,Pointpte）___
（2）___
voidLine:
:
PrintL（）
{
cout<<"1st";
pt1.PrintP（）;
cout<<"2nd";
pt2.PrintP（）;
cout<<"TheLengthofLine:
"<<___（3）___<}
（1）
（2）（3）
42.在下面一段类的定义中，自行车类的虚基类为车辆类，机动车类的虚基类也为车辆类，摩托车类的基类为自行车类和机动车类，类之间均为公有继承。
classvehicle//车辆类
{
private:
intMaxSpeed;//最大车速
intWeight;//车重
public:
vehic
升级会员 