C++面向对象程序设计》实验报告.docx

C++面向对象程序设计》实验报告.docx

《C++面向对象程序设计》实验报告.docx》由会员分享，可在线阅读，更多相关《C++面向对象程序设计》实验报告.docx（26页珍藏版）》请在冰豆网上搜索。

C++面向对象程序设计》实验报告

《C++面向对象程序设计》实验内容

实验1C++程序设计初步

1、实验目的

（1）了解在C++编译系统（VisualC++6.0）上如何编辑、编译、连接和运行一个C++程序。

（2）通过运行简单的C++程序，初步了解C++源程序的结构和特点。

（3）掌握简单C++程序的编写和调试方法。

（4）掌握重载函数的定义方法。

（5）能正确使用引用型变量。

2、实验内容和步骤

（1）在VisualC++环境下编译和运行C++程序

①先进入VisualC++6.0环境。

②在自己指定的子目录中建立一个名为test.cpp的新文件。

③从键盘输入以下程序

intmain（）

{

inta,b;

c=a+b;

cout>>“a+b=”>>a+b;

}

选择Build→Compiletest.cpp命令，对此源程序进行编译。

观察和分析编译信息。

⑤根据编译信息指出的错误，修改程序。

再进行编译，如果还有错，再重复此过程，直到编译不出错为止。

⑥选择Build→Buildtest.exe命令，对程序进行连接，如果不出错，就会生成可执行程序test.exe。

⑦选择Build→Executetest.exe命令，执行可执行程序test.exe。

观察屏幕的变化。

在输出窗口应显示程序运行结果。

⑧分析结果是否正确，如果不正确或认为输出格式不理想，可以修改程序，然后重新执行以上④和⑧步骤。

改过后的程序：

#include

usingnamespacestd;

intadd（intx,inty）

{

intz;

z=x+y;

return（z）;

}

intmain（）

{

inta,b,c;

cin>>a>>b;

c=add（a,b）;

cout<<"a+b="<

return0;

}

实验2C++对C的扩充

（2）编一个程序，用来求2个或3个正整数中的最大数。

#include

usingnamespacestd;

intmax2（intx,inty）;

intmax3（intx,inty,intz）;

intmain（）

{

inta,b,c,max;

cout<<"请输入两个数:

";

cin>>a>>b;

max=max2（a,b）;

cout<<"两者中的最大数为:

"<

cout<<"请输入三个数:

";

cin>>a>>b>>c;

max=max3（a,b,c）;

cout<<"三者中的最大数为:

"<

return0;

}

intmax2（intx,inty）

{

intm;

if（x>y）m=x;

elsem=y;

returnm;

}

intmax3（intx,inty,intz）

{

intm;

if（x>y&&x>z）m=x;

if（y>z&&y>x）m=y;

if（z>x&&z>y）m=z;

returnm;

}

（3）对3个变量按由小到大顺序排序，要求使用变量的引用。

#include

usingnamespacestd;

voidmain（）

{

inta,b,c,t;

cout<<"请输入三个整数:

";

cin>>a>>b>>c;

if（a>b）

{

t=a;

a=b;

b=t;

}

if（a>c）

{

t=a;

a=c;

c=t;

}

if（b>c）

{

t=b;

b=c;

c=t;

}

cout<

}

编写一个程序，用同一个函数名对10个数据进行从小到大的排序，数据类型可以是整形，单精度型、双精度型。

#include

usingnamespacestd;

voidmain（）

{

inti,j;

inta[10],b[11];

cout<<"请输入10个数:

"<

for（i=0;i<10;i++）

{

cin>>a[i];

}

for（i=0;i<10;i++）//对这10个数进行排序

{

for（j=0;j<10-i-1;j++）

if（a[j]>a[j+1]）

{

b[10]=a[j];

a[j]=a[j+1];

a[j+1]=b[10];

}

}

for（i=0;i<10;i++）//输出排序后的结果

{

cout<

}

cout<<"\n";

}

实验3类和对象

（一）

1、实验目的

（1）掌握声明类的方法，类和类的成员的的概念以及定义对象的方法。

（2）初步掌握用类和对象编制基于对象的程序。

（3）学习检查和调试基于对象的程序。

2、实验内容

（1）有以下程序：

#include

usingnamespacestd;

classTime//定义Time类

{public:

//数据成员为公用的

inthour;

intminute;

intsec;

};

intmain（）

{Timet1;//定义t1为Time类对象

cin>>t1.hour;//输入设定的时间

cin>>t1.minute;

cin>>t1.sec;

cout<

”<

”<

return0;

}

改写程序，要求：

①将数据成员改为私有的；

②将输入和输出的功能改为由成员函数实现；

③在类体内定义成员函数。

#include

usingnamespacestd;

classTime

{public:

inthour;

intminute;

intsec;

};

intmain（）

{

Timet1,t2,t3;

cin>>t1.hour;

cin>>t2.minute;

cin>>t3.sec;

cout<

"<

"<

return0;

}

然后编译和运行程序。

请分析什么成员应指定为公用的？

什么成员应指定为私有的？

什么函数最好放在类中定义？

什么函数最好放在类外定义？

（3）需要求3个长方柱的体积，请编一个基于对象的程序。

数据成员包括length（长）、width（宽）、height（高）。

要求用成员函数实现以下功能：

①由键盘分别输入3个长方柱的长、宽、高；

②计算长方柱的体积；

③输出3个长方柱的体积。

#include

usingnamespacestd;

classSquare

{

public:

voidprint（）;

voidcalc（）;

voiddisplay（）;

private:

intl;

intw;

inth;

intv;

};

voidSquare:

:

print（）

{

cin>>l;

cin>>w;

cin>>h;

}

voidSquare:

:

calc（）

{

v=l*w*h;

}

voidSquare:

:

display（）

{

cout<<"长方柱的体积为"<

}

voidmain（）

{

Squares;

s.print（）;

s.calc（）;

s.display（）;

}

请编程序，上机调试并运行。

学时数：

2学时

实验4类和对象

（二）

1、实验目的

（1）进一步加深对类和对象的理解。

（2）掌握类的构造函数和析构函数的概念和使用方法。

（3）掌握对对象数组、对象的指针及其使用方法。

（4）掌握友元的概念和使用。

（5）了解类模板的使用方法。

2、实验内容

（1）有以下程序：

#include

usingnamespacestd;

classDate;

classTime

{public:

Time（int,int,int）;

voiddisplay（Date&）;

private:

inthour;

intminute;

intsec;

};

classDate

{public:

Date（int,int,int）;

friendvoidTime:

:

display（Date&）;

private:

intmonth;

intday;

intyear;

};

Time:

:

Time（inth,intm,ints）

{hour=h;

minute=m;

sec=s;

}

voidTime:

:

display（Date&d）

{cout<

cout<

"<

"<

}

Date:

:

Date（intm,intd,inty）

{month=m;

day=d;

year=y;

}

intmain（）

{Timet1（10,13,56）;

Dated1（12,25,2004）;

t1.display（d1）;

return0;

}

请读者分析和运行此程序，注意友元函数Time:

:

display的作用。

将程序中的display函数不放在Time类中，而作为类外的普通函数，然后分别在Time和Date类中将display声明为友元函数。

在主函数中调用display函数，display函数分别引用Time和Date两个类的对象的私有数据，输出年、月、日和时、分、秒。

修改后上机调试和运行。

实验5运算符重载

1、实验目的

（1）进一步了解运算符重载的概念和使用方法。

（2）掌握几种常用的运算符重载的方法。

（3）了解转换构造函数的使用方法。

（4）了解在VisualC++6.0环境下进行运算符重载要注意的问题。

2、实验内容

事先编写好程序，上机调试和运行程序，分析结果。

（1）声明一个复数类Complex，重载运算符“+”、“-”、“*”、“/”，使之能用于复数的加、减、乘、除，运算符重载函数作为Complex类的成员函数。

编程序，分别求两个复数之和、差、积和商。

complex.h文件：

#include

classcomplex

{

private:

doubleRe,Im;//复数的实部与虚部

public:

complex（）{Re=Im=0;}//不带参数的构造函数

complex（doubler）{Re=r;Im=0;}//只置实部的构造函数

complex（doubler,doublei）{Re=r;Im=i;}//分别置实部、虚部的构造函数

doublegetReal（）{returnRe;}//取复数实部

doublegetImag（）{returnIm;}//取复数虚部

voidsetReal（doubler）{Re=r;}//修改复数实部

voidsetImag（doublei）{Im=i;}//修改复数虚部

complex&operator=（complex&ob）{Re=ob.Re;Im=ob.Im;}//复数赋值

complex&operator+（complex&ob）;//重载函数：

复数四则运算

complex&operator-（complex&ob）;

complex&operator*（complex&ob）;

complex&operator/（complex&ob）;

voidDisplay（）;

};

complex.cpp文件：

//复数类complex的相关服务的实现放在C++源文件complex.cpp中

#include

#include

#include"complex.h"

complex&complex:

:

operator+（complex&ob）

{

//重载函数：

复数加法运算。

complex*result=newcomplex（Re+ob.Re,Im+ob.Im）;

return*result;

}

complex&complex:

:

operator-（complex&ob）{

//重载函数：

复数减法运算

complex*result=newcomplex（Re-ob.Re,Im-ob.Im）;

return*result;

}

complex&complex:

:

operator*（complex&ob）{

//重载函数：

复数乘法运算

complex*result=

newcomplex（Re*ob.Re-Im*ob.Im,Im*ob.Re+Re*ob.Im）;

return*result;

}

complex&complex:

:

operator/（complex&ob）{

//重载函数：

复数除法运算

doubled=ob.Re*ob.Re+ob.Im*ob.Im;

complex*result=newcomplex（（Re*ob.Re+Im*ob.Im）/d,

（Im*ob.Re-Re*ob.Im）/d）;

return*result;

}

voidcomplex:

:

Display（）

{

if（fabs（Re）>0.00001）

cout<

if（fabs（Im）>0.00001）

{

if（Im>=0.0）

cout<<"+"<

else

cout<<"-"<

}

}

请思考：

你编的程序能否用于一个整数与一个复数的算术运算？

如4+（5-2i）

（2）声明一个复数类Complex，重载运算符“+”,使之能用于复数的加法运算。

参加运算的两个运算量可以都是类对象，也可以其中有一个是整数，顺序任意。

例如：

c1+c2，i+c1,c1+i，均合法（设i为整数，c1，c2为复数）。

运行程序，分别求两个复数之和、整数和复数之和。

#include

#include

#include

classComplex

{

public:

friendComplexoperator+（constComplex&cmp1,constComplex&cmp2）;

friendComplexoperator-（constComplex&cmp1,constComplex&cmp2）;

friendComplexoperator*（constComplex&cmp1,constComplex&cmp2）;

friendComplexoperator/（constComplex&cmp1,constComplex&cmp2）;

friendistream&operator>>（istream&ins,Complex&p）;

friendostream&operator<<（ostream&outs,Complex&p）;

Complex（）;

Complex（doublea）;

Complex（doublea,doublebi）;

private:

doublereal;

doubleimaginary;

};

istream&operator>>（istream&ins,Complex&p）

{

ins>>p.real>>p.imaginary;

returnins;

}

ostream&operator<<（ostream&outs,Complex&p）

{

outs<<"therationalis"<

returnouts;

}

Complex:

:

Complex（）

{

real=0;

imaginary=0;

}

Complex:

:

Complex（doublea）

{

real=a;

imaginary=0;

}

Complex:

:

Complex（doublea,doublebi）

{

real=a;

imaginary=bi;

}

Complexoperator+（constComplex&cmp1,constComplex&cmp2）

{

Complextemp;

temp.real=cmp1.real+cmp2.real;

temp.imaginary=cmp1.imaginary+cmp2.imaginary;

returntemp;

}

Complexoperator-（constComplex&cmp1,constComplex&cmp2）

{

Complextemp;

temp.real=cmp1.real-cmp2.real;

temp.imaginary=cmp1.imaginary-cmp2.imaginary;

returntemp;

}

Complexoperator*（constComplex&cmp1,constComplex&cmp2）

{

Complexa;

a.real=cmp1.real*cmp2.real+cmp1.imaginary*cmp2.imaginary;

a.imaginary=cmp1.real*cmp2.imaginary+cmp1.imaginary*cmp2.real;

returna;

}

Complexoperator/（constComplex&cmp1,constComplex&cmp2）

{

Complexc;

doublea;

a=cmp2.real*cmp2.real-cmp2.imaginary*cmp2.imaginary;

c.real=cmp1.real*cmp2.real-cmp1.imaginary*cmp2.imaginary;

c.real=c.real/a;

c.imaginary=cmp2.real*cmp1.imaginary-cmp1.imaginary*cmp2.real;

c.imaginary/=a;

returna;

}

intmain（）

{

Complexx1,x2（3.4,4）,x3;

x3=x1*x2;

cout<

x3=x1+x2;

cout<

x3=x1-x2;

cout<

cout<<"inputtwonumber!

"<

cin>>x3;

cout<

return0;

}

（3）有两个矩阵a和b，均为2行3列。

求两个矩阵之和。

重载运算符“+”，使之能用于矩阵相加。

如c=a+b。

如c=a+b。

#include

usingnamespacestd;

classJZ

{

public:

JZ（intm,intn）;

friendJZoperator+（JZ&jz1,JZ&jz2）;

friendistream&operator>>（istream&input,JZ&jz）;

friendostream&operator<<（ostream&output,JZ&jz）;

private:

int*pt;

intjz;

intm;

intn;

};

JZ:

:

JZ（intm,intn）

{m=2;n=3;

intjz[m][n];

}

JZoperator+（JZ&jz1,JZ&jz2）

{JZjz3（2,3）;

jz1.pt=&（jz1.jz）;

jz2.pt=&（jz2.jz）;

jz3.pt=&（jz3.jz）;

for（inti=0;i<2;i++）

for（intj=0;j<3;j++）

{*（jz3.pt）=*（jz1.pt）+*（jz2.pt）;

cout<<*（jz3.pt）<<"";

jz3.pt++;

jz2.pt++;

jz1.pt++;

}

cout<

returnjz3;

}

ostream&operator<<（ostream&output,JZ&jz）

{jz.pt=&jz.jz;

for（inti=0;i<2;i++）

for（intj=0;j<3;j++）

{cout<<*（jz.pt）<<"";

jz.pt++;}

cout<

returnoutput;

}

istream&operator>>（istream&input,JZ&jz）

{

jz.pt=&jz.jz;

for（inti=0;i<2;i++）

for（intj=0;j<3;j++）

{cin>>*（jz.pt）;

jz.pt++;}

jz.pt=&jz.jz;

for（inti=0;i<2;i++）

for（intj=0;j<3;j++）

{cout<<*jz.pt<<"";

jz.pt++;}

cout<

jz.pt=&jz.jz;

returninput;

}

intmain（）

{

JZa（2,3）;

cin>>a;

JZb（2,3）;

cin>>b;

JZc（2,3）;

c=a+b;

cout<

return0;

}

（4）声明一个Teacher（教师）类和一个Student（学生）类，二者有一部分数