类与对象.docx
《类与对象.docx》由会员分享，可在线阅读，更多相关《类与对象.docx（17页珍藏版）》请在冰豆网上搜索。
类与对象
南昌大学实验报告
一、实验名称
实验4类与对象
二、实验目的
类是C++扩展数据类型，可以封装不同类型的数据成员和函数成员，类是面向对象程序设计的基础。
本次实验内容包括面向对象的基本概念、构造函数与析构函数，从实际问题抽象出类等，通过实验要求：
1、掌握面向对象的基本概念，类的定义方法；
2、掌握类成员的访问权限及访问类成员的方法；
3、掌握内联函数；
4、掌握引用概念及应用，引用作为函数参数；
5、掌握构造函数与析构函数的意义及使用方法。
三、实验内容
1、验证课本例子4-7
2、课本4-11，4-13
3、程序输出的结果：
classComplex
{
private:
doublem_real;
doublem_imag;
public:
Complex（void）
{
m_real=0.0;
m_imag=0.0;
cout<<"调用了构造函数Complex（void）"<}
Complex（doublereal,doubleimag）
{
m_real=real;
m_imag=imag;
cout<<"调用了构造函数Complex（doublereal,doubleimag）"<}
Complex（constComplex&c）
{
//将对象c中的数据成员值复制过来
m_real=c.m_real;
m_imag=c.m_imag;
cout<<"调用了拷贝构造函数Complex（constComplex&c）"<}
Complex:
:
Complex（doubler）
{
m_real=r;
m_imag=0.0;
cout<<"调用了构造函数Complex（doubler）"<}
Complex&operator=（constComplex&rhs）
{
//首先检测等号右边的是否就是左边的对象本，若是本对象本身,则直接返回
if（this==&rhs）
{
return*this;
}
//复制等号右边的成员到左边的对象中
this->m_real=rhs.m_real;
this->m_imag=rhs.m_imag;
//把等号左边的对象再次传出
//目的是为了支持连等eg:
a=b=c系统首先运行b=c
//然后运行a=（b=c的返回值,这里应该是复制c值后的b对象）
cout<<"调用了=操作符重载"<return*this;
}
};
voidmain（）
{
Complexc1,c2;
Complexc3（1.0,2.5）;
Complexc4=Complex（1.0,2.5）;
c1=c3;
c2=5.2;
Complexc5（c2）;
Complexc6=c2;
}
（1）仔细观察复制构造函数,为什么函数中可以直接访问对象c的私有成员？
Complex（constComplex&c）
{
//将对象c中的数据成员值复制过来
m_real=c.m_real;
m_img=c.m_img;
}
（2）分析引用与传值的区别
Complextest1（constComplex&c）
{
returnc;
}
Complextest2（constComplexc）
{
returnc;
}
voidmain（）
{
Complexa,b;
//下面函数执行过程中各会调用几次构造函数，调用的是什么构造函数？
test1（a）;
test2（a）;
test2（1.2）;
//下面这条语句会出错吗？
test1（1.2）; //test1（Complex（1.2））呢？
}
4、有一根27厘米的细木杆，在第3厘米、7厘米、11厘米、17厘米、23厘米这五个位置上各有一只蚂蚁。
木杆很细，不能同时通过一只蚂蚁。
开始时，蚂蚁的头向（右，左，右，左，左），它们只会朝前走或调头，但不会后退。
当任意两只蚂蚁碰头时，两只蚂蚁会同时调头朝反方向走。
假设蚂蚁们每秒钟可以走一厘米的距离。
定义一个蚂蚁类Ant，编写程序，求所有蚂蚁都离开木杆的时间。
四、实验环境
PC微机
Windows7操作系统
MicrosoftVisualStudio2012集成开发环境；
MicrosoftVisualStudio2012集成开发环境的MSDN
五、实验步骤
编程实现实验内容
1.实验结果
2．
4-11源代码
#include
usingnamespacestd;
//类的声明
classRectangle
{
private:
intlenth;
intwidth;
public:
intgetLength（）;
intgetWidth（）;
intcalArea（）;
Rectangle（）;
~Rectangle（）;
Rectangle（intlen,intwid）;
Rectangle（constRectangle&rec）;
};
intRectangle:
:
getLength（）
{
returnlenth;
}
intRectangle:
:
getWidth（）
{
returnwidth;
}
intRectangle:
:
calArea（）
{
returnlenth*width;
}
Rectangle:
:
Rectangle（）
{
}
Rectangle:
:
~Rectangle（）
{
}
Rectangle:
:
Rectangle（intlen,intwid）
{
this->lenth=len;
this->width=wid;
}
Rectangle:
:
Rectangle（constRectangle&rec）
{
this->lenth=rec.lenth;
this->width=rec.width;
}
voidmain（）
{
intlength,width;
cout<<"请输入长方形的长和宽:
"<cin>>length>>width;
RectangleR1（length,width）;
cout<<"初始化一个长为4，宽为6的长方形"<RectangleR2（5,6）;
RectangleR3（R1）;
RectangleR4（R2）;
cout<<"R1的长是:
"<"<"<cout<<"R2的长是:
"<"<"<cout<<"R3的长是:
"<"<"<cout<<"R4的长是:
"<"<"<system（"pause"）;
}
输出结果：
4-13源代码
#include
usingnamespacestd;
#definePI3.14159
classCircle
{
private:
floatRadius;
public:
Circle（floatradius）{Radius=radius;}
~Circle（）{}
floatgerArea（）{returnPI*Radius*Radius;}
};
intmain（）
{
floatradius;
cout<<"请输入圆的半径：
";
cin>>radius;
CircleC（radius）;
cout<<"这个圆的半径为：
"<"<system（"pause"）;
}
输出结果
3、
（1）仔细观察复制构造函数,为什么函数中可以直接访问对象c的私有成员？
Complex（constComplex&c）
{
//将对象c中的数据成员值复制过来
m_real=c.m_real;
m_img=c.m_img;
}
这里是直接调用 对象c的复制构造函数，用来构造一个新对象。
因此可以直接访问
（2）分析引用与传值的区别
Complextest1（constComplex&c）
{
returnc;
}
Complextest2（constComplexc）
{
returnc;
}
voidmain（）
{
Complexa,b;
//下面函数执行过程中各会调用几次构造函数，调用的是什么构造函数？
test1（a）;
test2（a）;
test2（1.2）;
//下面这条语句会出错吗？
test1（1.2）; //test1（Complex（1.2））呢？
}
以上函数运行的结果：
4、源代码
#include
#include
usingnamespacestd;
classAnt
{
private:
intspeed;
intposition;
intdriection;//0表示左，1表示右
public:
Ant（intsp,intpos,intdir）;
intgetPosition（）;
intgetDriection（）;
boolisLeave（）;
voidsetDriection（intdir）;
voidmoveLeft（）;
voidmoveRight（）;
};
voidAnt:
:
moveLeft（）
{
position-=speed;
}
voidAnt:
:
moveRight（）
{
position+=speed;
}
Ant:
:
Ant（intsp,intpos,intdir）
{
speed=sp;
position=pos;
driection=dir;
}
intAnt:
:
getPosition（）
{
returnthis->position;
}
intAnt:
:
getDriection（）
{
returnthis->driection;
}
voidAnt:
:
setDriection（intdir）
{
this->driection=dir;
}
boolAnt:
:
isLeave（）
{
if（this->position>27||this->position<0）
returntrue;
else
returnfalse;
}
//蚂蚁移动
voidmoves（Ant&a）
{
if（a.getDriection（）==1）
a.moveRight（）;
else
a.moveLeft（）;
}
//////////////////////////////////////////////////////////////////////////
//显示蚂蚁位置
//////////////////////////////////////////////////////////////////////////
voiddisplay（Anta1,Anta2,Anta3,Anta4,Anta5）
{
cout<<"\t";
cout<setw（a2.getPosition（）-a1.getPosition（）+1）<<""<<"*"<<
setw（a3.getPosition（）-a2.getPosition（）+1）<<""<<"*"<<
setw（a4.getPosition（）-a3.getPosition（）+1）<<""<<"*"<<
setw（a5.getPosition（）-a4.getPosition（）+1）<<""<<"*"<cout<<"\t";
for（inti=0;i<40;i++）
cout<<"_";
cout<}
//蚂蚁移动的逻辑判断
voidmove（Ant&aL,Ant&a,Ant&aR）
{
if（!
a.isLeave（））
{
if（a.getDriection（）==1）
if（aR.getDriection（）!
=a.getDriection（））
{
if（（aR.getPosition（）-a.getPosition（））==1）
{
a.setDriection（abs（a.getDriection（）-1））;
aR.setDriection（abs（a.getDriection（）-1））;
moves（a）;
}
else
moves（a）;
}
else
moves（a）;
else
{
if（a.getDriection（）!
=aL.getDriection（））
{
if（（a.getPosition（）-aL.getPosition（））==1）
{
a.setDriection（abs（a.getDriection（）-1））;
aL.setDriection（abs（aL.getDriection（）-1））;
moves（a）;
}
else
moves（a）;}
else
moves（a）;
}
}
}
voidmain（）
{
intlength=27,time=0;
Anta0（0,-10,0）,a6（0,37,1）;//两只虚拟蚂蚁
Anta1（1,3,1）,a2（1,7,0）,a3（1,11,1）,a4（1,17,0）,a5（1,23,0）;
cout<<"蚂蚁的实时位置：
"<while
（1）
{
move（a0,a1,a2）;
move（a1,a2,a3）;
move（a2,a3,a4）;
move（a3,a4,a5）;
move（a4,a5,a6）;
display（a1,a2,a3,a4,a5）;
time++;
if（a1.isLeave（）&&a2.isLeave（）&&a3.isLeave（）&&a4.isLeave（）&&a5.isLeave（））
break;
}
cout<<"总共花了"<system（"pause"）;
}
六、实验总结及体会
通过本次实验，我更加深刻的理解面向对象的概念，同时对类这个概念也有了更深的理解，特别是在构造函数的调用和拷贝构造函数的调用，什么时候调用构造函数，什么时候调用拷贝构造函数，调用几次。
在初始化时只调用构造函数。
升级会员 