复习提纲.docx
《复习提纲.docx》由会员分享，可在线阅读，更多相关《复习提纲.docx（36页珍藏版）》请在冰豆网上搜索。
复习提纲
一、编程题
1、编写一个程序，求5个数中的最小的数（数存放在数组中，为简单编程，数据可以定义的时候给出，不用从键盘上输入）。
（数据类型为整形，长整形，双精度）用函数模板实现。
2、编写一个程序，用来求2个或3个正整数中的最大值，要求用函数重载方法实现。
3、用new和delete实现动态分配和撤销空间实现二维数组的输入和输出。
（从键盘上输入）
#include
usingnamespacestd;
intmain（）
{
int（*p）[2]=newint[3][2];
for（inti=0;i<3;i++）
{
for（intj=0;j<2;j++）
{
cin>>p[i][j];
}
}
for（i=0;i<3;i++）
{
for（intj=0;j<2;j++）
{
cout<}
cout<}
cout<delete[]p;
return0;
}
4、考察类的对象数组：
建立一个对象数组，内放5个学生的数据（学号，成绩），用指针指向数组首元素，输出第1,3,5个学生的数据。
（书P306第4题）
描述：
类student:
数据：
学号（intnum）；成绩（floatscore）。
函数：
构造函数：
采用参数初始化表的定义
输出函数：
display（）:
输出学号和成绩
主函数：
定义一个student类的对象数组，里面存放5个学生数据（学号，成绩），用指针指向数组首元素，输出第1,3,5个学生的数据。
#include
usingnamespacestd;
classstudent
{
public:
student（intn,floats）:
num（n）,score（s）{}
voiddisplay（）;
private:
intnum;
floatscore;
};
voidstudent:
:
display（）
{
cout<}
intmain（）
{
studentstud[5]={
student（1001,85）,
student（1002,80）,
student（1003,84）,
student（1004,86）,
student（1005,88）};
student*p=stud;
for（inti=0;i<2;p+=2,i++）
{
p->display（）;
}
return0;
}
5、设计一个整型二维数组类，数据包含：
（1）三行四列二维数组，
（2）最大值；成员函数包含
（1）实现输入二维数组元素；
（2）实现输出二维数组元素（3）实现输出二维数组中的最大值。
要求按下列要求写出各个文件中的源代码。
（1）类的定义放在头文件array2.h中；选用C++HeaderFile
classarray_max
{
public:
voidset_value（）;
voidmax_value（）;
voidshow_value（）;
private:
intarray[3][4];
intmax;
};
（2）类中成员函数定义放在源文件array2.cpp文件中;
#include
usingnamespacestd;
#include"array2.h"
voidarray_max:
:
set_value（）
{
for（inti=0;i<3;i++）
{
for（intj=0;j<4;j++）
{
cin>>array[i][j];
}
}
}
voidarray_max:
:
max_value（）
{
max=array[0][0];
for（inti=0;i<3;i++）
{
for（intj=0;j<4;j++）
{
if（array[i][j]>max）
max=array[i][j];
}
}
}
voidarray_max:
:
show_value（）
{
cout<<"max="<}
（3）主函数放在源文件main.cpp文件中
#include"array2.h"
intmain（）
{
array_maxarrmax;
arrmax.set_value（）;
arrmax.max_value（）;
arrmax.show_value（）;
return0;
}
6、商品销售某一商品，商店每天公布统一的折扣（discount）。
同时允许销售人员在销售时灵活掌握售价（price），在此基础上，对一次购10件以上者，还可以享受9.8折优惠。
现已知当天3个销售员的销售情况为：
销货员号（num）销货件数（quantity）销货单价（price）
101523.5
1021224.56
10310021.5
请编写程序，计算当日此商品的总销售款sum以及每件商品的平均售价。
要求用静态数据成员和静态成员函数。
程序代码如下：
#include
usingnamespacestd;
classproduct
{
private:
intnum;
intquantity;
floatprice;
staticfloatdiscount;
staticfloatsum;
staticintn;
public:
product（intm,intq,floatp）:
num（m）,quantity（q）,price（p）{}
voidtotal（）;
staticfloataverage（）;
staticvoiddisplay（）;
};
floatproduct:
:
discount=0.05;
floatproduct:
:
sum=0;
intproduct:
:
n=0;
voidproduct:
:
total（）
{if（quantity<10）
{n+=quantity;
sum+=quantity*price*（1-discount）;
}
else
{n+=quantity;
sum+=quantity*price*（1-discount）*0.98;
}
}
floatproduct:
:
average（）
{
returnsum/n;
}
voidproduct:
:
display（）
{
cout<:
average（）<}
intmain（）
{
productp[3]={
product（101,5,23.5）,
product（102,12,24.56）,
product（103,100,21.5）
};
for（inti=0;i<3;i++）
{p[i].total（）;
}
p[i].display（）;
return0;
}
7、定义一个类模板point
该类模板包含数据为x（横坐标），y（纵坐标）；
成员函数包含：
（1）构造函数：
采用参数的初始化表形式实现，默认值都为0；
（2）voidsetxy（）:
对x,y进行赋值，通过参数传递。
（3）voidshowxy（）:
输出横坐标和纵坐标
（4）getx（）:
返回点的横坐标；gety（）:
返回点的纵坐标
主函数实现的功能是：
定义一个点的坐标是整形，一个点的坐标的实型的，分别输出两点坐标。
#include
usingnamespacestd;
template
classpoint
{
public:
point（ntypea,ntypeb）;
voidsetxy（ntypem,ntypen）;
voidshowxy（）;
getx（）;
gety（）;
private:
ntypex,y;
};
template
point:
:
point（ntypea=0,ntypeb=0）:
x（a）,y（b）{}
template
voidpoint:
:
setxy（ntypem,ntypen）
{
x=m;
y=n;
}
template
voidpoint:
:
showxy（）
{
cout<<"（"<}
template
point:
:
getx（）
{
returnx;
}
template
point:
:
gety（）
{
returny;
}
intmain（）
{
pointp1（2,3）;
p1.showxy（）;
pointp2（2.1,3.2）;
p2.showxy（）;
return0;
}
8、声明一个复数类complex，重载运算符“+”，“-”，“*”，“/”,使之能用于复数的加，减，乘，除，运算符重载作为complex类的成员函数，编写程序，分别求两个负数的之和，差，积和商。
#include
classcomplex
{
public:
complex（）{real=0;imag=0;}
complex（doubler,doublei）{real=r;imag=i;}
complexoperator+（complex&c2）;
complexoperator-（complex&c2）;
complexoperator*（complex&c2）;
complexoperator/（complex&c2）;
voiddisplay（）;
private:
doublereal;
doubleimag;
};
voidcomplex:
:
display（）
{
cout<<"（"<}
complexcomplex:
:
operator+（complex&c2）
{
returncomplex（real+c2.real,imag+c2.imag）;
}
complexcomplex:
:
operator-（complex&c2）
{
returncomplex（real-c2.real,imag-c2.imag）;
}
complexcomplex:
:
operator*（complex&c2）
{complexc5;
c5.real=（real*c2.real）-（imag*c2.imag）;
c5.imag=imag*c2.real+real*c2.imag;
returnc5;
}
complexcomplex:
:
operator/（complex&c2）
{
complexc6;
c6.real=（（real*c2.real）+（imag*c2.imag））/（c2.real*c2.real+c2.imag*c2.imag）;
c6.imag=（imag*c2.real-real*c2.imag）/（c2.real*c2.real+c2.imag*c2.imag）;
returnc6;
}
intmain（）
{
complexc1（3,4）,c2（5,6）,c3,c4,c5,c6;
c3=c1+c2;
c4=c1-c2;
c5=c1*c2;
c6=c1/c2;
cout<<"c1+c2=";c3.display（）;
cout<<"c1-c2=";c4.display（）;
cout<<"c1*c2=";c5.display（）;
cout<<"c1/c2=";c6.display（）;
return0;
}
9、声明一个Time类，类中包含私有数据hour（时）,minute（分）,second（秒）,公共函数包含：
（1）Time（）：
无参构造函数，初始化为0；
（2）Time（inth,intm,ints）：
有参构造函数，赋值；
（3）重载+：
采用友元函数
friendTimeoperator+（Time&t1,Time&t2）;重载+作为友员函数
（4）voidgettime（）：
输出时间
主函数，定义两个时间类对象，t1（8,51,40）,t2（4,15,30）,求t1+t2的值并且输出。
程序代码如下：
#include
classTime
{
public:
Time（）{hour=0;minute=0;sec=0;}
Time（inth,intm,ints）:
hour（h）,minute（m）,sec（s）{}
friendTimeoperator+（Time&t1,Time&t2）;
voiddisplay（）{cout<"<"<private:
inthour;
intminute;
intsec;
};
Timeoperator+（Time&t1,Time&t2）
{
Timet;
t.hour=t1.hour+t2.hour;
t.minute=t1.minute+t2.minute;
t.sec=t1.sec+t2.sec;
if（t.sec>=60）
{t.minute++;
t.sec-=60;
}
if（t.minute>=60）
{t.minute-=60;
t.hour++;
}
returnTime（t.hour,t.minute,t.sec）;
}
intmain（）
{
Timet1（8,51,40）,t2（4,15,30）,t3;
t3=t1+t2;
t3.display（）;
return0;
}
10、有两个矩阵a和b，均为2行3列。
求两个矩阵之和。
重载运算符“+”，使之能用于矩阵相加。
如c=a+b。
重载流插入运算符“<<”和流提取运算符“>>”，使之能用于矩阵的输入和输出。
#include
classmartix
{
public:
martix（）;
friendmartixoperator+（martix&,martix&）;
voidinput（）;
voiddisplay（）;
private:
intmat[2][3];
};
martix:
:
martix（）
{for（inti=0;i<2;i++）
{
for（intj=0;j<3;j++）
{
mat[i][j]=0;
}
}
}
martixoperator+（martix&a,martix&b）
{martixc;
for（inti=0;i<2;i++）
{
for（intj=0;j<3;j++）
{
c.mat[i][j]=a.mat[i][j]+b.mat[i][j];
}
}
returnc;
}
voidmartix:
:
input（）
{
cout<<"inputvaluesofmartix:
"<for（inti=0;i<2;i++）
for（intj=0;j<3;j++）
cin>>mat[i][j];
}
voidmartix:
:
display（）
{
for（inti=0;i<2;i++）
{
for（intj=0;j<3;j++）
{
cout<}
cout<}
}
intmain（）
{martixa,b,c;
a.input（）;
b.input（）;
cout<"<a.display（）;
cout<"<b.display（）;
c=a+b;
cout<"<c.display（）;
return0;
}
11、设计一个多重继承，实现输出圆桌的高度、颜色和面积。
父类为圆类circle和桌子类table，派生出圆桌类roundtable。
其中圆类circle中包含数据半径，实现数据初始化和求圆的面积；桌子类table中包含数据高度，实现数据初始化和返回桌子高度；圆桌类roundtable包含数据颜色，实现数据初始化、返回圆桌颜色以及输出圆桌信息，包含高度、面积和颜色。
类的设计如下：
#include
#include
usingnamespacestd;
classcircle
{
public:
circle（doubler）
{
radius=r;
}
voidgetarea（）
{
cout<<3.14*radius*radius<}
protected:
doubleradius;
};
classtable
{
public:
table（doubleh）
{
height=h;
}
doublegetheight（）
{
returnheight;
}
protected:
doubleheight;
};
classroundtable:
publiccircle,publictable
{
public:
roundtable（doubler,doubleh,stringc）:
circle（r）,table（h）
{color=c;}
voiddisplay（）
{cout<<"面积：
";
getarea（）;
cout<<"高度：
";
cout<cout<<"颜色：
";
cout<}
private:
stringcolor;
};
intmain（）
{
roundtablero（3,5,"红"）;
ro.display（）;
return0;
}
12、设计一个虚继承，实现输出沙发床的面积、高度、颜色、品牌以及沙发床的功能。
父类为沙发类sofa和床类bed，派生出沙发床类sofabed，沙发类sofa和床类bed共同的数据为长度和宽度。
其中沙发类sofa中包含数据颜色、实现数据初始化和输出沙发的功能；床类bed包含数据高度，实现数据初始化和输出床的功能；沙发床类sofabed中包含数据品牌，输出沙发床面积、高度、颜色和品牌以及输出沙发床功能。
#include
#include
usingnamespacestd;
classN
{
public:
N（doublel,doublew）
{length=l;width=w;}
protected:
doublelength;
doublewidth;
};
classbed:
virtualpublicN
{public:
bed（doublel,doublew,doubleh）:
N（l,w）
{
height=h;
}
doublebedarea（）
{
returnlength*width;
}
voidsleep（）
{
cout<<"bedisforsleeping!
"<}
protected:
doubleheight;
};
classsofa:
virtualpublicN
{public:
sofa（doublel,doublew,stringc）:
N（l,w）
{
color=c;
}
voidwatchingTV（）
{
cout<<"sofaisforWatchingTV!
"<}
protected:
stringcolor;
};
classsofabed:
publicbed,publicsofa
{
public:
sofabed（doublel,doublew,doubleh,stringc,stringb）:
N（l,w）,bed（l,w,h）,sofa（l,w,c）
{
band=b;
}
voiddisplay（）
{
cout<<"面积"<}
voidgonneng（）
{
sleep（）;
watchingTV（）;
}
private:
stringband;
};
intmain（）
{
sofabeds（10.2,8.6,4.3,"红","艾尔"）;
s.display（）;
s.gonneng（）;
return0;
}
13、编写一个程序，实现如下功能：
基类为point类，数据为点的横、纵坐标，实现数据初
始化、返回横、纵坐标，对流插入运算符重载输出点的信息；派生类为line类，数据包含：
从点类继承的线的起始坐标，基类的子对象（线的终点坐标），线的颜色，实现数据初始化、对流插入运算符重载输出线的信息（包含点的起始和终点坐标，线的距离和颜色；point类和line类中均有计算距离的函数。
输出点和线的信息，以及利用多态性实现输出点和线的距离。
#include
#include
#include
classpoint
{
public:
point（inta,intb）:
x（a）,y（b）{}
intgetx（）{returnx;}
intgety（）{returny;}
virtualdoubledistance（）{return0.0;}
friendostream&operator<<（ostream&,point&）;
升级会员 