运算符重载实验报告

本文格式为Word版，下载可任意编辑——运算符重载实验报告实

验

报

告

课程名称

程序设计语言C/C++

试验工程

运算符重载

一、试验目的

1、理解重载运算符的意义；

2、把握成员函数、友元函数重载运算符的定义及使用方法；

3、把握动态联编、虚函数、纯虚函数和抽象类的概念；4、把握虚函数、纯虚函数和抽象类的定义及使用方法。

二、试验内容

1.上机分析下面程序，把握运算符重载的方法。

要求：

（1）给出试验结果；（2）把握重载"+、-、、='运算符重载的方法。

#includeiostreamusingnamespacestd;

classCOMPLEX

{

public:

COMPLEX(doubler=0,doublei=0);

//构造函数

COMPLEX(constCOMPLEXother);

//拷贝构造函数

voidprint();

//打印复数

COMPLEXoperator+(constCOMPLEXother);

//重载加法运算符（二元）

COMPLEXoperator-(constCOMPLEXother);

//重载减法运算符（二元）

COMPLEXoperator-();

//重载求负运算符（一元）

COMPLEXoperator=(constCOMPLEXother);

//重载赋值运算符（二元）

protected:

doublereal,image;

//复数的实部与虚部

};

COMPLEX::COMPLEX(doubler,doublei){

real=r;

image=i;}

COMPLEX::COMPLEX(constCOMPLEXother)

{

real=other.real;

image=other.image;}

voidCOMPLEX::print(){

coutreal;

if(image0)

cout+imagei;

elseif(image0)

coutimagei;

coutendl;}

COMPLEX

COMPLEX::operator+(constCOMPLEXother){

COMPLEXtemp;

temp.real=real+other.real;

//real=real+other.real;

temp.image=image+other.image;

//image=image+other.image;

returntemp;

//*this;}

COMPLEXCOMPLEX::operator-(constCOMPLEXother){

COMPLEXtemp;

temp.real=real-other.real;

temp.image=image-other.image;

returntemp;

}

COMPLEXCOMPLEX::operator-(){

COMPLEXtemp;

temp.real=-real;

temp.image=-image;

returntemp;}

COMPLEXCOMPLEX::operator=(constCOMPLEXother){

real=other.real;

image=other.image;

return*this;

//返回对象值}

intmain()

{

COMPLEXc1(1,2);

//定义一个值为1+2i的复数c1

COMPLEXc2(2);

//定义一个值为2的复数c2

COMPLEXc3(c1);

//用COMPLEX(constCOMPLEXother)创立一个值同c1的新复数

c3.print();

//打印c3原来的值

c1=c1+c2+c3;

//将c1加上c2再加上c3赋值给c1

c2=-c3;

//c2等于c3求负

c3=c2-c1;

//c3等于c2减去c1

c3.print();

//再打印运算后c3的值

coutsizeof(c1)endl;

return0;

}2.上机分析下面程序，给出输出结果。

要求：

（1）给出试验结果；

（2）把握友元运算符重载的基本方法：通过重载cout语句，可使用cout输出对象的数据成员值的方法。

#includeiostream.hclassT{

intx,y;

public:

T(inta,intb)

{x=a;y=b;}

friendostreamoperator(ostreamos,Ta);};

ostreamoperator(ostreamos,Ta){osx=a.x

y=a.y;

returnos;}

voidmain(){

Ta(1,2);

coutaendl;}

3、上机分析下面程序，把握抽象类、纯虚函数以及动态绑定的定义和使用。

要求：

（1）给出试验结果；

（2）把握抽象类、纯虚函数以及动态绑定的方法。

//shape.h文件定义抽象基类Shape

#ifndefSHAPE_H#defineSHAPE_HclassShape{

public:

virtualdoubleArea()const

{

return0.0;

}

//纯虚函数，在派生类中重载

virtualvoidPrintShapeName()const=0;

virtualvoidPrint()const=0;};#endif

//point.h文件定义类Point#ifndefPOINT_H#definePOINT_H#includeiostreamusingnamespacestd;classPoint:publicShape{

intx,y;

//点的x和y坐标

public:

Point(int=0,int=0);

//构造函数

voidSetPoint(inta,intb);

//设置坐标

intGetX()const//取x坐标

{

returnx;

}

intGetY()const//取y坐标

{

returny;

}

virtualvoidPrintShapeName()const

{

coutPoint:;

}

virtualvoidPrint()const;//输出点的坐标};#endif

//Point.cpp文件

Point类的成员函数定义

#includeiostreamusingnamespacestd;

Point::Point(inta,intb):x(a),y(b)

{}voidPoint::SetPoint(inta,intb)

{

x=a;

y=b;}

voidPoint::Print()const

{

cout"["x,y"]";}

//circle.h定义类Circle

#ifndefCIRCLE_H

#defineCIRCLE_H

#includeiostreamusingnamespacestd;

classCircle:publicPoint

{

doubleradius;

public:

Circle(intx=0,inty=0,doubler=0.0);

voidSetRadius(doubler);

//设置半径

doubleGetRadius()const;

//取半径

virtualdoubleArea()const;

//计算面积a

virtualvoidPrint()const;

//输出圆心坐标和半径

virtualvoidPrintShapeName()const

{

coutCircle:;

}

};

#endif

//circle.cpp文件

circle类的成员函数定义

Circle::Circle(inta,intb,doubler):Point(a,b),radius(r)

{}

voidCircle::SetRadius(doubler)

{

radius=(r=0?r:0);

}

doubleCircle::GetRadius()const

{

returnradius;

}

doubleCircle::Area()const

{

return3.14159*radius*radius;}

voidCircle::Print()const

{

coutCenter=;

Point::Print();

cout;Radius=radiusendl;

}

//main.cpp文件演示图形类

#includeiostream

usingnamespacestd;

voidvirtualViaPointer(constShape*);

voidvirtualViaReference(constShape);

intmain()

{

Pointpoint(30,50);

//创立point、circle对象

Circlecircle(120,80,10.0);

point.PrintShapeName();

//输出point、circle、rectangle对象信息

point.Print();

coutendl;

circle.PrintShapeName();

circle.Print();

Shape*arrayOfShapes[2];

//定义基类对象指针

arrayOfShapes[0]=point;

arrayOfShapes[1]=circle;

coutVirtualfunctioncallsmadeoffbase-classpointers\n;

//通过基类对象指针访问派生类对象

for(inti=0;i2;i++)

{

virtualViaPointer(arrayOfShapes[i]);

}

coutVirtualfunctioncallsmadeoffbase-classreferences\n;

for(intj=0;j2;j++)

{

virtualViaReference(*arrayOfShapes[j]);

}

return0;}voidvirtualViaPointer(constShape*baseClassPtr)

//通过基类对象指针访问虚函数实现动态绑定

{

baseClassPtr-PrintShapeName();

baseClassPtr-Print();

coutArea=baseClassPtr-Area()endl;

}//通过基类对象引用访问虚函数实现动态绑定

voidvirtualViaReference(constShapebaseClassRef){

baseClassRef.PrintShapeName();

baseClassRef.Print();

coutArea=baseClassRef.Area()endl;}4、上机完成下面试验。

声明一个Shape（外形）基类，它有两个派生类：Circle（圆）和Square（正方形），要求利用多态性的概念，分别以虚函数的形式完成对圆和正方形的周长及面积的计算。

要求：Shape类的数据成员包括中心点的坐标，Circle类和Square类初始值分别给出：

圆的圆心和半径；正方形的中心和一个顶点。

（参考）

实数矩阵类//头文件MatrixException.h

#includestdexcept

#includestring

usingnamespacestd;

classMatrixException:publiclogic_error

{

public:

MatrixException(conststrings):logic_error(s)

{}

};

classSingular:publicMatrixException

{

public:

Singular(conststrings):MatrixException(Singular:+s)

{}

};classInvalidIndex:publicMatrixException

{

public:

InvalidIndex(conststrings):MatrixException(Invalidindex:+s)

{}

};

classIncompatibleDimension:publicMatrixException

{

public:

IncompatibleDimension(conststrings):MatrixException(IncompatibleDimensions:+s)

{}};

//头文件Matrix.h//#includeMatrixException.h

classMatrix

{

private:

double*elems;

//存放矩阵中各元素，按行存放

introw,col;

//矩阵的行与列

protected:

doublerowTimesCol(inti,constMatrixb,intj)const;

//矩阵的第i行矩阵b的第j列相乘

public:

Matrix(intr,intc);

Matrix(double*m,intr,intc);

Matrix(constMatrixm);

~Matrix();

//重载运算符=，实现矩阵赋值，若进行运算的矩阵维数不同，抛出IncompatibleDimension异常

Matrixoperator=(constMatrixb)throw(IncompatibleDimension);

//重载运算符()，用来返回某一个矩阵元素值,若所取矩阵下标非法，抛出InvalidIndex异常

doubleoperator()(inti,intj)throw(InvalidIndex);

constdoubleoperator()(inti,intj)constthrow(InvalidIndex);

//给矩阵元素赋值，若所设置矩阵元素下标非法，抛出InvalidIndex异常

voidSetElem(inti,intj,doubleval)throw(InvalidIndex);

//重载运算符*，实现矩阵相乘,若前一个矩阵的列数不等于后一个矩阵的行数，抛出IncompatibleDimension异常

Matrixoperator*(constMatrixb)constthrow(IncompatibleDimension);

//重载运算符+，实现矩阵相加,若进行运算的矩阵维数不同，抛出IncompatibleDimension异常

Matrixoperator+(constMatrixb)constthrow(IncompatibleDimension);

//重载运算符-，实现矩阵相减//若进行运算的矩阵维数不同，抛出IncompatibleDimension异常

Matrixoperator-(constMatrixb)constthrow(IncompatibleDimension);

voidPrint()const;

//按行显示输出矩阵中各元素

};

//成员函数的定义文件Matrix.cpp

#includeiostream

#includestrstream

#includestring

//#includeMatrix.h

usingnamespacestd;

stringint2String(inti)

//将整型数转换为String类型

{

charbuf[64];

ostrstreammystr(buf,64);

mystri"\0";

returnstring(buf);

}

Matrix::Matrix(intr,intc)

{

if(r0c0)

{

row=r;

col=c;

elems=newdouble[r*c];//为矩阵动态分派存储

}

else

{

elems=NULL;

row=col=0;

}

}Matrix::Matrix(double*m,intr,intc)

{

if(r0c0)

{

row=r;

col=c;

elems=newdouble[r*c];

}

else

{

elems=NULL;

row=col=0;

}

if(elems!=NULL)

{

for(inti=0;ir*c;i++)

{

elems[i]=m[i];

}

}

}

Matrix::Matrix(constMatrixm):row(m.row),col(m.col){

if(NULL==m.elems)

{

elems=NULL;

}

else

{

inttotal=row*col;

elems=newdouble[total];

for(inti=0;itotal;++i)

{

elems[i]=m.elems[i];

}

}

}

Matrix::~Matrix()

{

delete[]elems;//释放矩阵所占的存储

}MatrixMatrix::operator=(constMatrixb)

throw(IncompatibleDimension)

{

if(this==b)

{

return*this;

}

if(col!=b.col||row!=b.row

)

{

throw(IncompatibleDimension(Matrix+int2String(row)

+x+int2String(col)+equailsmatrix

+int2String(b.row)+x+int2String(b.col)+.));

}

row=b.row;

col=b.col;

delete[]elems;

if(NULL==b.elems)

{

elems=NULL;

}

else

{

inttotal=row*col;

elems=newdouble[total];

for(inti=0;itotal;++i)

{

elems[i]=b.elems[i];

}

}

return*this;

}//重载运算符()可以由给出的矩阵行列得到相应的矩阵元素值。之所以重载()而不是[]，是由于避免数组elems所造成的二义性

doubleMatrix::operator()(intr,intc)throw(InvalidIndex)

{

if(r0||r=row||c0||c=col)

{

throw(InvalidIndex(string(GetElement()

+int2String(r)+,+int2String(c)+)

+from(

+int2String(row)+x

+int2String(col)+)+matrix.));

}

returnelems[r*col+c];

}

constdoubleMatrix::operator()(intr,intc)constthrow(InvalidIndex)

{

if(r0||r=row||c0||c=col)

{

throw(InvalidIndex(string(GetElement()

+int2String(r)+,+int2String(c)+)

+from(

+int2String(row)+x

+int2String(col)+)+matrix.));

}

returnelems[r*col+c];

}

voidMatrix::SetElem(intr,intc,doubleval)throw(InvalidIndex)

{

if(r0||r=row||c0||c=col)

{

throw(InvalidIndex(string(SetElement()

+int2String(r)+,+int2String(c)+)

+for(

+int2String(row)+x

+int2String(col)+)+matrix.));

}

elems[r*col+c]=val;

}

MatrixMatrix::operator*(constMatrixb)constthrow(IncompatibleDimension)

{

if(col!=b.row)

//incompatibledimensions

{

throw(IncompatibleDimension(Matrix+int2String(row)

+x+int2String(col)+timesmatrix

+int2String(b.row)+x+int2String(b.col)+.));

}

Matrixans(row,b.col);

for(intr=0;rrow;r++)

{

for(intc=0;cb.col;c++)

{

ans.SetElem(r,c,rowTimesCol(r,b,c));

}

}

returnans;}

MatrixMatrix::operator+(constMatrixb)constthrow(IncompatibleDimension)

{

if(col!=b.col||row!=b.row

)

{

throw(IncompatibleDimension(Matrix+int2String(row)

+x+int2String(col)+addsmatrix

+int2String(b.row)+x+int2String(b.col)+.));

}

Matrixans(row,col);

for(intr=0;rrow;r++)

{

for(intc=0;ccol;c++)

{

ans.SetElem(r,c,elems[r*col+c]+b.elems[r*col+c]);

}

}

returnans;

}

MatrixMatrix::operator-(constMatrixb)constthrow(IncompatibleDimension)

{

if(col!=b.col||row!=b.row

)

{

throw(IncompatibleDimension(Matrix+int2String(row)

+x+int2String(col)+minusmatrix

+int2String(b.row)+x+int2String(b.col)+.));

}

Matrixans(row,col);

for(intr=0;rrow;r++)

{

for(intc=0;ccol;c++)

{

ans.SetElem(r,c,elems[r*col+c]-b.elems[r*col+c]);

}

}

returnans;}

voidMatrix::Print()const

{

for(inti=0;irow;i++)

{

for(intj=0;jcol-1;j++)

{

coutelems[i*col+j]\t;

}

coutelems[i*col+col-1];

coutendl;

}

coutendl;

}

doubleMatrix::rowTimesCol(inti,constMatrixb,intj)const

{

doublesum=0.0;

for(intk=0;kcol;k++)

{

sum+=elems[i*col+k]*b.elems[k*b.col+j];

}

returnsum;}

//测试文件MatrixMain.cpp

#includeiostream

//#includeMatrix.h

usingnamespacestd;

intmain()

{

try

{

//创立矩阵对象

doublea[20]={1.0,3.0,-2.0,0.0,4.0,-2.0,-1.0,5.0,-7.0,2.0,0.0,8.0,4.0,1.0,-5.0,3.0,-3.0,2.0,-4.0,1.0};

doubleb[15]={4.0,5.0,-1.0,2.0,-2.0,6.0,7.0,8.0,1.0,0.0,3.0,-5.0,9.0,8.0,-6.0};

Matrixx1(a,4,5);

coutthematrixofx1is:endl;

x1.Print();

Matrixy1(b,5,3);

coutthematrixofy1is:endl;

y1.Print();

Matrixz1=x1*y1;

//两个矩阵相乘

coutthematrixofz1=x1*y1is:endl;

z1.Print();

Matrixx2(2,2);

x2.SetElem(0,0,1.0);//为矩阵对象添加元素

x2.SetElem(0,1,2.0);

x2.SetElem(1,0,3.0);

x2.SetElem(1,1,4.0);

coutthematrixofx2is:endl;

x2.Print();

coutx1*x2is:endl;

x1*x2;

//两个维数不匹配矩阵相乘，产生异常

coutx1-x2is:endl;

x1-x2;

//两个维数不匹配矩阵相减，产生异常

coutSetanewelementforx1:endl;

x1.SetElem(7,8,30);

//设置矩阵元素超界，产生异常

coutGetaelementfromx1:endl;

x1(4,5);

//取不存在的矩阵元素，产生异常

}

catch(MatrixExceptione)

{

coute.what()endl;//获取异常信息

}

return0;

}三、试验步骤及结果分析

1.程序的类结构图为：

COMPLEX

#real:double#image:double+COMPLEX(doubler=0,doublei=0)+COMPLEX(constCOMPLEXother)+print():void

+operator+(constCOMPLEXother):COMPLEX+operator-(constCOMPLEXother):COMPLEX+operator-():COMPLEX+operator=(constCOMPLEXother):COMPLEX

运行结果

2.程序的类结构图为：

TT

x,y:int

+T(inta,intb)

+operator(ostreamos,Ta):friendostream

运行结果

3.程序的类结构图为：

Shape

++AArea():virtualdouble

const

+PrintShapeName():virtualvoid

const

+Print():virtualvoid

const

Pointx,y:int+Point(int=0,int=0)

+SetPoint(inta,intb):void

+GetX():intconst

+GetY():intconst

+PointShapeName():virtualvoidconst

+Print():virtualvoidconst

Circle

rradius:double

++Circle(intx=0,inty=0,doubler=0.0)

++SetRadius(doubler):void

++GetRadius():doubleconst

++Area():virtualdoubleconst

++Print():virtualvoidconst

++PrintShapeName():virtualvoidconst

运行结果

4.程序的类结构图为：

Shape11

#x_size,y_size:double

+Shape11(doublex,doubley)

+area():virtualdouble

+perimeter():virtualdoublee

+print():virtualvoid

相关代码：

#includeiostream

usingnamespacestd;classShape1{

protected:

doublex_size,y_size;

public:

Shape1(doublex,doubley);

//构造函数

virtualdoublearea()

//纯虚函数，在派生类中重载

{

return0.0;Circle11

#radius:double

+Circle1(doublee

x=0.0,doubley=0.0,doubler=0.0)

+set_radius(doubler=0.0):void

+get_radius():double

+area():virtualdouble

+perimeter():virtualdouble

+print():virtualvoid

Square11

#i_size,j_size:double

+Square11(doublex=0.0,doubley=0.0,

ddouble

i=0.0,doublej=0.0)

+set_i(doublei):void

+set_j(double_j):void

+get_i():void

++gget_j():void

+area():virtualdouble

+perimeter():virtualdouble

+print():virtualvoid

}

virtualdoubleperimeter()

{

return0.0;

}

virtualvoidprint()=0;};

Shape1::Shape1(doublea,doubleb){

x_size=a;

y_size=b;}

classCircle1:publicShape1{

protected:

doubleradius;

public:

Circle1(doublex=0.0,doubley=0.0,doubler=0.0);//构造函数

voidset_radius(doubler=0.0);

//设置半径

doubleget_radius();

//输出半径

virtualdoublearea();

virtualdoubleperimeter();

virtualvoidprint();

//输出圆心坐标和半径};

Circle1::Circle1(doub