河北工业大学C++实验报告实验四.docx

河北工业大学C++实验报告实验四.docx

《河北工业大学C++实验报告实验四.docx》由会员分享，可在线阅读，更多相关《河北工业大学C++实验报告实验四.docx（18页珍藏版）》请在冰豆网上搜索。

河北工业大学C++实验报告实验四

1、编写一个程序，要求：

（1）生明一个类Complex（复数类），定义类Complex的两个对象c1和c2，对象c1通过构造函数直接指定复数的实部和虚部（类私有数据成员为double类型：

real和imag）为2.5及3.7，对象c2通过构造函数直接指定复数的实部和虚部为4.2及6.5；

（2）定义友元运算符重载函数，它以c1、c2对象为参数，调用该函数时能返回两个复数对象相加操作；

（3）定义成员函数print，调用该函数时，以格式“real+imagi”输出当前对象的实部和虚部，例如：

对象的实部和虚部分别是4.2和6.5，则调用print函数输出格式为：

4.2+6.5i；

（4）编写主程序，计算出复数对象c1和c2相加结果，并将其结果输出。

#include

usingnamespacestd;

classComplex

{

public:

Complex（doubler=0.0,doublei=0.0）;

friendComplexoperator+（Complex&a,Complex&b）;

voidprintf（）;

private:

doublereal;

doubleimag;

};

Complex:

:

Complex（doubler,doublei）

{

real=r;

imag=i;

}

Complexoperator+（Complex&a,Complex&b）

{

Complextemp;

temp.real=a.real+b.real;

temp.imag=a.imag+b.imag;

returntemp;

}

voidComplex:

:

printf（）

{

cout<

if（imag>0）

cout<<"+";

if（imag!

=0）

cout<

}

voidmain（）

{

Complexc1（2.5,3.7）,c2（4.2,6.5）,c3;

c3=c1+c2;

c3.printf（）;

}

2、编写一个程序，其中设计一个时间类Time，用来保存时、分、秒等私有数据成员，通过重载操作符“+”实现两个时间的相加。

要求将小时范围限制在大于等于0，分钟范围限制在0~59分，秒钟范围限制在0~59秒。

提示：

时间类Time的参考框架如下：

classTime

{

public:

Time（inth=0,intm=0,ints=0）;//构造函数

Timeoperator+（Time&）;//运算符重载函数，实现两个时间的相加

voiddisptime（）;//显示时间函数

private:

inthours,minutes,seconds;

};

#include

usingnamespacestd;

classTime

{

public:

Time（inth=0,intm=0,ints=0）;//构造函数

Timeoperator+（Time&）;//运算符重载函数，实现两个时间的相加

voiddisptime（）;//显示时间函数

private:

inthours;

intminutes;

intseconds;

};

Time:

:

Time（inth,intm,ints）

{

hours=h;

minutes=m;

seconds=s;

}

TimeTime:

:

operator+（Time&t）

{

inth,m,s;

s=（t.seconds+seconds）%60;

m=（minutes+t.minutes+（t.seconds+seconds）/60）%60;

h=hours+t.hours+（minutes+t.minutes+（t.seconds+seconds）/60）/60;

hours=h;

minutes=m;

seconds=s;

return*this;

}

voidTime:

:

disptime（）

{

cout<

"<

"<

}

voidInput（int&h,int&m,int&s）

{

cout<<"输入时间:

";

cin>>h;

cin>>m;

cin>>s;

while（m<0||m>59||s<0||s>59）

{

cout<<"******时间输入错误！

请重新输!

******\n";

cout<<"输入时间:

";

cin>>h;

cin>>m;

cin>>s;

}

}

intmain（）

{

inth1,m1,s1,h2,m2,s2;

Input（h1,m1,s1）;

Input（h2,m2,s2）;

TimeA（h1,m1,s1）,B（h2,m2,s2）;

A=A+B;

A.disptime（）;

return0;

}

3、用友元运算符函数或成员运算符函数，重载运算符“+”、“-”、“*”，实现对实验二中实现的矩阵类的对象的加、减、乘法。

#include

#definehang2

#definelie2

classMatrix

{

private:

intRow;

intColumn;

intMATRIX[hang][lie];

public:

Matrix（intr,intc）

{

Row=r;

Column=c;

}

Matrix（）{}

voidTypeMatrix（）;

voidPrint（）const;

Matrix&operator=（constMatrix&rhs）;

Matrixoperator+（constMatrix&rhs）;

Matrixoperator-（constMatrix&rhs）;

};

voidMatrix:

:

TypeMatrix（）

{

std:

:

cout<<"请输入矩阵:

"<

:

endl;

for（inti=0;i

{

for（intj=0;j

{

std:

:

cin>>MATRIX[i][j];

}

}

}

voidMatrix:

:

Print（）const

{

std:

:

cout<<"矩阵的结果为:

"<

:

endl;

for（intq=0;q

{

for（ints=0;s

{

std:

:

cout<

if（s==lie-1）

{

std:

:

cout<

:

endl;

}

}

}

}

Matrix&Matrix:

:

operator=（constMatrix&rhs）

{

if（this!

=&rhs）

{

for（intg=0;g

{

for（inth=0;h

{

this->MATRIX[g][h]=rhs.MATRIX[g][h];

}

}

}

return*this;

}

MatrixMatrix:

:

operator+（constMatrix&rhs）

{

inti,j;

for（i=0;i

{

for（j=0;j

{

MATRIX[i][j]=this->MATRIX[i][j]+rhs.MATRIX[i][j];

}

}

return*this;

}

MatrixMatrix:

:

operator-（constMatrix&rhs）

{

inti,j;

for（i=0;i

{

for（j=0;j

{

MATRIX[i][j]=this->MATRIX[i][j]-rhs.MATRIX[i][j];

}

}

return*this;

}

intmain（）

{

Matrixa,b,c,d;

a.TypeMatrix（）;

b.TypeMatrix（）;

c=a+b;

c.Print（）;

d=a-b;

d.Print（）;

}

4、编写一个程序，用于进行集合的和、并和交运算。

例如输入整数集合{9,5,4，3,6,7}和{2,4,6,9}，计算出他们进行集合的并、差和交运算后的结果。

【提示】

（1）可以用一下表达式实现整数集合的基本运算：

s1+s2两个整数集合的并运算

s1-s2两个整数集合的差运算

s1*s2两个整数集合的交运算

（2）参考以下Set类的框架，用于完成集合基本运算所需的各项功能。

classSet

{

public:

Set（）;

voidinput（intd）;//向集合中添加一个元素

intlength（）;//返回集合中的元素个数

intgetd（inti）;//返回集合中位置i的元素

voiddisplay（）;//显示集合的所有元素

Setoperator+（Sets1）;//成员运算符重载函数，实现集合的并运算

Setoperator-（Sets1）;//成员运算符重载函数，实现集合的差运算

Setoperator*（Sets1）;//成员运算符重载函数，实现集合的交运算

Setoperator=（Sets1）;//成员运算符重载函数，实现集合的赋值运算

protected:

intlen;//统计结合中元素的个数；

ints[MAX];//存放集合中的元素

};

#include

usingnamespacestd;

constintMAX=50;

classset

{

public:

set（）;

voidinput（intd）;

intlength（）;

intgetd（inti）;

voiddisp（）;

setoperator+（sets1）;

setoperator-（sets1）;

setoperator*（sets1）;

setoperator=（sets1）;

protected:

intlen;

ints[MAX];

};

set:

:

set（）

{

len=0;

//s={0};

cout<<"***建立一个集合***\n";

}

voidset:

:

input（intd）

{

len=d;

cout<<"输入集合元素"<

";

for（inti=0;i

cin>>s[i];

}

intset:

:

length（）

{

intn=0;

while（s[n]!

='\0'）

{

n++;

}

returnn;

}

intset:

:

getd（inti）

{

return0;

}

voidset:

:

disp（）

{

for（inti=0;i

cout<

//cout<

}

setset:

:

operator+（sets1）//------------------------并运算----------------

{

//strcat（s,s1.s）;

for（inti=0;i

{

for（intj=0;j

{

if（s[i]==s1.s[j]）//选出相同的元素删掉得到s1.s与s不同的元素

{

for（;j

s1.s[j]=s1.s[j+1];

--s1.len;

}

}

}

for（intj=0;j

{

s[len]=s1.s[j];

len++;

}

s[len+s1.len]='\0';

return*this;

}

setset:

:

operator-（sets1）//------------------------差运算------------------

{

intt;

for（inti=0;i

{

for（intj=0;j

{

if（s1.s[i]==s[j]）//选出s与s1.s中相同的元素并且删除掉

{

t=j;

for（;t

s[t]=s[t+1];

--len;

}

}

}

return*this;

}

setset:

:

operator*（sets1）//-------------------交运算----------------------

{

intm[MAX];

intl=0;

for（inti=0;i

{

for（intj=0;j

{

if（s1.s[i]==s[j]）

{

m[l]=s[j];

l++;

}

}

}

for（i=0;i

s[i]=m[i];

s[l]='\0';

len=l;

return*this;

}

setset:

:

operator=（sets1）

{

for（inti=0;i

s[i]=s1.s[i];

len=s1.len;

return*this;

}

intmain（）

{

intn;

setC;

setA;

cout<<"建立含有几个元素的集合：

";

cin>>n;

A.input（n）;

setB;

cout<<"建立含有几个元素的集合：

";

cin>>n;

B.input（n）;

cout<

cout<<"两集合的差集（A-B）为：

";

C=A-B;

C.disp（）;

cout<

/*

cout<<"两集合的交集（A*B）为：

";

C=A*B;

C.disp（）;

cout<

*/

/*

cout<<"两集合的并集（A+B）为：

";

C=A+B;

C.disp（）;

cout<

*/

return0;

}

……………………说明分别分开运行……………………

6、写一个程序，定义抽象类Container：

classContainer

{

protected:

doubleradius;

public:

Container（doubler）;//抽象类Container的构造函数

virtualdoublesurface_area（）=0;//纯虚函数surface_area

virtualdoublevolume（）=0;//纯虚函数volume

};

【要求】

建立3个继承Container的派生类：

Sphere（球体）、Cylinder（圆柱体）、Cube（正方体），让每一个派生类都包含虚函数surface_area（）和volume（），分别用来球体、圆柱体和正方体的表面积和体积。

要求写出主程序，应用C++的多态性，分别计算边长为6.0的正方体、半径为5.0的球体，以及半径为5.0和高为6.0的圆柱体的表面积和体积。

#include

#include

usingnamespacestd;

classcontainer

{

protected:

doubleradius;

public:

container（doubleradius1）;

virtualdoublesurface_area（）=0;

virtualdoublevolume（）=0;

};

container:

:

container（doubleradius1）

{

radius=radius1;

}

//派生类cube、sphere与cylinder

classcube:

publiccontainer

{

public:

cube（doubleradius1）:

container（radius1）{}

virtualdoublesurface_area（）;

virtualdoublevolume（）;

};

doublecube:

:

surface_area（）

{

return6*radius*radius;

}

doublecube:

:

volume（）

{

returnradius*radius*radius;

}

classsphere:

publiccontainer

{

public:

sphere（doubleradius1）:

container（radius1）

{}

virtualdoublesurface_area（）;

virtualdoublevolume（）;

};

doublesphere:

:

surface_area（）

{

return4*3.14*radius*radius;

}

doublesphere:

:

volume（）

{

return4.0/3.0*3.14*radius*radius*radius;

}

classcylinder:

publiccontainer

{

protected:

doublehigh;

public:

cylinder（doublehigh1,doubleradius1）:

container（radius1）

{high=high1;

}

virtualdoublesurface_area（）;

virtualdoublevolume（）;

};

doublecylinder:

:

surface_area（）

{

return2*3.14*radius*radius+2*3.14*high*radius;

}

doublecylinder:

:

volume（）

{

return3.14*radius*radius*high;

}

intmain（）

{

container*p;

cubecc（6.0）;

spheress（5.0）;

cylindercy（6.0,5.0）;

p=&cc;

cout<<"正方体的表面积:

"<surface_area（）<

cout<<"正方体的体积:

"<volume（）<

p=&ss;

cout<<"球体的表面积:

"<surface_area（）<

cout<<"球体的体积:

"<volume（）<

p=&cy;

cout<<"圆柱体的表面积:

"<surface_area（）<

cout<<"圆柱体的体积:

"<volume（）<

return0;

}