类与对象.docx

类与对象.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"）;

}

六、实验总结及体会

通过本次实验，我更加深刻的理解面向对象的概念，同时对类这个概念也有了更深的理解，特别是在构造函数的调用和拷贝构造函数的调用，什么时候调用构造函数，什么时候调用拷贝构造函数，调用几次。

在初始化时只调用构造函数。