#include<iostream>
#include<iomanip>
using namespace std;
class Matrix{
private:
SetValue int X;unsigned int y;
static int ObjectAliveNo;
int a,b;
public:
unsigned int **pMatrix;
Matrix(unsigned int x,unsigned int y){
a=x;b=y;
int **pMatrix=new int *[y];
for(int i=0;i<x;i++)
pMatrix[i]=new int[y];
cout<<"矩阵的行数："<<x<<endl;
cout<<"矩阵的列数："<<y<<endl;
for(i=0;i<x*y;i++)
{cin>>**pMatrix;
*pMatrix++;}
++ObjectAliveNo;
}
Matrix(){}
~Matrix(){--ObjectAliveNo;}
int getx(){return a;}
int gety(){return b;}
};
int Matrix::ObjectAliveNo=0;
void Mul(Matrix a,Matrix b){
int t,i,j,x,y,p[80];
int c=0;
i=a.getx();j=a.gety();x=b.getx();y=b.gety();
if(j!=x)
exit(1);
else
for(int e=0;e<i;e++)
for(int f=0;f<y;f++)
{for(int g=0;g<j;g++)
t+=a.pMatrix[i][j]*b.pMatrix[j][y];
p[c]=t;c++;
t=0;}
cout<<"输出相乘后的矩阵："<<endl;
for(c=0;c<i*y;c++)
{if(c%i==0)
cout<<endl;
cout<<setw(2)<<p[c];
}
cout<<endl;
}
void main(){
Matrix a(2,2),b(2,2);
Mul(a,b);
}1． 重载运算符“*”，实现对以上实验实现的矩阵类的对象的相乘。
2． 定义一个类BaseFly，该类中有一个Fly()函数。
3． 定义三个类BirdFly、DragonFly、PlaneFly，都集成来自BaseFly，并重载Fly()函数。
4． 用各类指针调用各个类的对象的Fly()函数，体会继承中的多态性。
5． 将BaseFly::Fly()函数声明为virtual，体会需函数在多态性中的作用。
三．实验方法与步骤
1． 重载运算符“*”进行矩阵相乘，相乘的算法代码请参考实验3中的Mul()函数。这里给出一个示例，在矩阵相乘之前要检查两个矩阵是否可以相乘，之后根据矩阵相乘的定义返回一个新的矩阵。
//---------------------------------------------------------------------------------------------------
Matrix Matrix::operator*(Matrix &m)
{
if(iMaxy!=m.iMaxx)//check the validity
{
cout<<"\nCannot multipiy Matrix a with b!\n";
return *this;
}
int ix,iy,iz;
Matrix c(iMaxx,m.iMaxy);
for(ix=0;ix<iMaxx;ix++)
for(iy=0;iy<m.iMaxy;iy++)
{
c.pMatrix[ix][iy]=0;
for(iz=0;iz<iMaxy;iz++)
{
c.pMatrix[ix][iy]+=pMatrix[ix][iy]*m.pMatrix[ix][iy];
}
}
return c;
}
//---------------------------------------------------------------------------------------------------
2． 下面提供一个体会继承中的多态性和虚函数在多态性中的作用的题目。请根据提示进行实验。定义类BaseFly()函数输出特定内容。例如：
//---------------------------------------------------------------------------------------------------
class BaseFly
{
public:
void Fly()
{ cout<<"\n-------Class BaseFly::Fly()------\n"; }
};
//---------------------------------------------------------------------------------------------------
3． 定义类BirdFly、DragonFly和PlaneFly，都继承自BaseFly，重载Fly()函数使得各类中的Fly()函数分别输出不同的内容。
//---------------------------------------------------------------------------------------------------
class BirdFly:public BaseFly
{
public:
void Fly(){cout<<"\n------ Class BirdFly::Fly()-----\n";}
};
Class DragonFly:public BaseFly
{
public:
void Fly(){cout<<"\n------ Class DragonFly::Fly()-----\n";}
};
class PlaneFly:public BaseFly
{
public:
void Fly(){ cout<<"\n------ Class PlaneFly::Fly()-----\n";}
};
//---------------------------------------------------------------------------------------------------
4． 在main函数中，用“new”关键字分配出以上四个类的实例，调用各个例的Fly()函数测试多太性。请参考以下代码：
//---------------------------------------------------------------------------------------------------
int main()
{
cout<<"\n测试继承中的多态性（Virtual）:\n";
BaseFly *pBase;
BirdFly *pBird=new Bird();
PBase=pBird;
cout<<"\nBirdFly->\n";
PBase->Fly();
DragonFly *pDragon=new DragonFly();
Pbase=pDragon;
Cout<<"\n DragonFly->\n";
PBase->Fly();
PlaneFly *pPlane=new PlaneFly();
Pbase= pPlane;
Cout<<"\n PlaneFly->\n";
PBase->Fly();
return 0;
}
//---------------------------------------------------------------------------------------------------
5． 将BaseFly::Fly()声明为virtual，在main（）中定义BaseFly的指针：* Pbase，依次分别指向BirdFly、DragonFly和PlaneFly，并调用各类的Fly()函数，体会需函数作用。
//---------------------------------------------------------------------------------------------------
BaseFly* Pbase＝new BaseFly;
BirdFly* pBird=new BirdFly
Pbase=pBird;