Question

求用C++编写一个4x4矩阵运算类（元素float），实现转置和相乘，具体见补充，在线等！谢谢啦～

编写一个矩阵类CMyMatrix
1.矩阵4行4列，元素float
2.实现矩阵相乘
3.实现矩阵转制函数
4.独立编写调用代码，验证

Answer 1

我大一写的，当时自学的C++，许多地方写的不对，不过楼主凑合看吧：
#include<iostream>
#include<cstdlib>
#include<cstdio>
#include<cmath>
#include<cstring>
using namespace std;
class determinant
{
public:
determinant()
{
int i,j;
sideLenth=2;
array=new double*[sideLenth];
for(i=0;i<sideLenth;i++)
{
array[i]=new double[sideLenth];
}
for(i=0;i<sideLenth;i++)
{
for(j=0;j<sideLenth;j++)
{
array[i][j]=0;
}
}
}
determinant(int sideLenth)
{
int i,j;
this->sideLenth=sideLenth;
array=new double*[sideLenth];
for(i=0;i<sideLenth;i++)
{
array[i]=new double[sideLenth];
}
for(i=0;i<sideLenth;i++)
{
for(j=0;j<sideLenth;j++)
{
array[i][j]=0;
}
}
}
~determinant()
{
for(int i=0;i<sideLenth;i++)
{
delete []array[i];
}
delete []array;
}
void setdeterminant();
double calculate();
double equal();
double **array;
int getsideLenth();
double calCofactor(int m,int n);//m是横标，n是纵标
void show();//用于测试
protected:
int sideLenth;
private:
double caltwo();
void copy(determinant& forCal);
void exchangeCorOrRow(determinant& forCal,int m,int n,bool colorrow);
};
int determinant::getsideLenth()
{
return sideLenth;
}
void determinant::setdeterminant()
{
for(int j=0;j<sideLenth;j++)
{
for(int i=0;i<sideLenth;i++)
{
cin>>array[i][j];
}
}
}
double determinant::calculate()
{
if(sideLenth==2)
{
return caltwo();
}
double result=0.0;
for(int i=0;i<sideLenth;i++)
{
result+=calCofactor(i,0)*array[i][0];
}
return result;
}
double determinant::calCofactor(int m,int n)
{
int yi=0,yj=0;
int i;
determinant yzs(sideLenth-1);
for(i=0;i<sideLenth;i++)
{
if(i!=m)
{
for(int j=0;j<sideLenth;j++)
{
if(j!=n)
yzs.array[yi][yj++]=array[i][j];
}
yi++;
yj=0;
}
}
double tmp=yzs.calculate();
if((m+n)%2==1)
tmp=-tmp;
return tmp;
}
double determinant::caltwo()
{
if(sideLenth!=2)
{
cout<<"错误！"<<endl;
return 0.0;
}
else
{
return array[0][0]*array[1][1]-array[0][1]*array[1][0];
}
}
double determinant::equal()
{
if(sideLenth<4)
{
return calculate();
}
determinant forCal(sideLenth);
copy(forCal);
bool b=true;
for(int i=0;i<sideLenth-1;i++)//i为需要化下三角的列
{
if(forCal.array[i][i]==0)
{
for(int k=i+1;k<sideLenth;k++)
{
if(forCal.array[k][i]!=0)
{
exchangeCorOrRow(forCal,i,k,true);
b=!b;
break;
}
}
if(k==sideLenth)
return 0;
}
for(int j=i+1;j<sideLenth;j++)//j为需要化下三角的行
{
if(forCal.array[i][j]!=0)
{
double times=forCal.array[i][j]/forCal.array[i][i];
for(int k=i;k<sideLenth;k++)
{
forCal.array[k][j]-=(forCal.array[k][i]*times);
}
}
}
}
double result=1;
for(i=0;i<sideLenth;i++)
{
result*=forCal.array[i][i];
}
if(!b)result=-result;
return result;
}
void determinant::copy(determinant& forCal)
{
int i,j;
if(forCal.sideLenth!=sideLenth)
{
cout<<"大小不同，无法复制"<<endl;
return ;
}
for(i=0;i<sideLenth;i++)
{
for(j=0;j<sideLenth;j++)
{
forCal.array[i][j]=array[i][j];
}
}
}
void determinant::exchangeCorOrRow(determinant& forCal,int m,int n,bool colorrow)
{
double temp;
if(m>=sideLenth||n>=sideLenth||m<0||n<0)
{
cout<<"参数错误"<<endl;
return;
}
if(colorrow)//true时为交换列
{
for(int i=0;i<sideLenth;i++)
{
temp=forCal.array[i][m];
forCal.array[i][m]=forCal.array[i][n];
forCal.array[i][n]=temp;
}
}
else//false时为交换行
{
for(int i=0;i<sideLenth;i++)
{
temp=forCal.array[m][i];
forCal.array[m][i]=forCal.array[n][i];
forCal.array[n][i]=temp;
}
}
}
void determinant::show()
{
for(int i=0;i<sideLenth;i++)
{
for(int j=0;j<sideLenth;j++)
{
printf("%-6.2lf",array[j][i]);
}
printf("\n");
}
}
class matrix
{
private:
int row;//行标最大值
int col;//列标最大值
void copyToDeterminant(determinant& destination);
void equalConvers(int rs,int rd,int cs,double factor);
void divideRow(int r,int cs,double factor);
void exchangerow(int rs,int rd);
public:
double **array;
matrix(){row=0;col=0;}
void setArray();//初始化二维数组
matrix(int row,int col);
~matrix();
void setmatrix();//给矩阵赋值
void show();
void inverse();
void transportation();
friend void multiplication(matrix& result,const matrix& faciend,const matrix& multiplicator);
int stairlize(int start,int end);
int getrow(){return row;}
int getcol(){return col;}
};
void matrix::setArray()
{
int i,j;
array=new double*[row];
for(i=0;i<row;i++)
{
array[i]=new double[col];
}
for(i=0;i<col;i++)
{
for(j=0;j<row;j++)
{
array[j][i]=0;
}
}
}
matrix::matrix(int row,int col)
{
this->row=row;
this->col=col;
setArray();
}
matrix::~matrix()
{
int i;
for(i=0;i<row;i++)
{
delete []array[i];
}
delete []array;
array=NULL;
}
void matrix::setmatrix()
{
if(row==0||col==0)
{
throw "矩阵没有被初始化\n";
}
int i,j;
for(i=0;i<col;i++)
{
for(j=0;j<row;j++)
{
scanf("%lf",&array[j][i]);
}
}
}
void matrix::show()
{
int i,j;
for(i=0;i<col;i++)
{
for(j=0;j<row;j++)
{
printf("%.2lf ",array[j][i]);
}
printf("\n");
}
}
void multiplication(matrix& result,const matrix& faciend,const matrix& multiplicator)
{
if(faciend.row!=multiplicator.col)
throw "左矩阵的列数必须等于右矩阵的行数\n";
result.row=multiplicator.row;
result.col=faciend.col;
result.setArray();
int times=faciend.row;
int m,n,i;
for(n=0;n<result.row;n++)
{
for(m=0;m<result.col;m++)
{
double resultNumber=0.0;
for(i=0;i<times;i++)
{
resultNumber+=faciend.array[i][m]*multiplicator.array[n][i];
}
result.array[n][m]=resultNumber;
}
}
}
void matrix::copyToDeterminant(determinant& destination)
{
if(row!=col)
throw "只有矩阵行数和列数相等时才能复制到行列式\n";
if(row!=destination.getsideLenth())
throw "行列式的大小与矩阵不匹配\n";
int i,j;
for(i=0;i<row;i++)
{
for(j=0;j<col;j++)
{
destination.array[i][j]=array[i][j];
}
}
}
void matrix::transportation()
{
if(row!=col)
throw "只有矩阵行数和列数相等时才可逆\n";
determinant tmpDeterminant(row);
copyToDeterminant(tmpDeterminant);
double value=tmpDeterminant.equal();
if(value==0)
{
printf("行列式的值为%lf,故矩阵不可逆\n",value);
return;
}
int i,j;
for(i=0;i<row;i++)
{
for(j=0;j<col;j++)
{
array[j][i]=tmpDeterminant.calCofactor(i,j)/value;
}
}
}
void matrix::inverse()
{
int i,j;
for(i=0;i<col-1;i++)//纵标
{
for(j=i+1;i<row;i++)//横标
{
double tmp=array[j][i];
array[j][i]=array[i][j];
array[i][j]=tmp;
}
}
}
void matrix::equalConvers(int rs,int rd,int cs,double factor)//rs是起始行标ds是目标行cs是起始列
{
for(int i=cs;i<row;i++)
{
array[i][rd]-=array[i][rs]*factor;
// printf("array[%d][%d]=%.2lf ",i,rd,array[i][rd]);
}
// printf("\n");
}
void matrix::exchangerow(int rs,int rd)
{
for(int i=0;i<row;i++)
{
double tmp;
tmp=array[i][rs];
array[i][rs]=array[i][rd];
array[i][rd]=tmp;
}
}
void matrix::divideRow(int r,int cs,double factor)
{
for(int i=cs;i<row;i++)
{
array[i][r]/=factor;
}
}
int matrix::stairlize(int start,int end)
{
int i,j;
double factor;
int R=0;
if(start<0||end>=row||start>end)
{
cout<<"传入参数有误"<<endl;
return 0;
}
for(i=start;i<=end;i++)//是横标
{
if(array[R][i]==0)
{
int k;
for(k=R+1;k<col;k++)
{
if(array[i][k])
{
exchangerow(i,k);
break;
}
}
if(k==col)
{
continue;
}
}
for(j=0;j<col;j++)
{
if(array[i][j]&&j!=R)
{
factor=array[i][j]/array[i][R];
equalConvers(R,j,i,factor);
}
}
R++;
}
for(i=0;i<=R;i++)
{
for(j=i;j<row;j++)
{
if(array[j][i])
{
divideRow(i,j,array[j][i]);
break;
}
}
}
return R;
}
void main()
{
cout<<"请选择想要进行的运算"<<endl;
cout<<"1.行列式求值"<<endl;
cout<<"2.矩阵相乘"<<endl;
cout<<"3.矩阵的逆"<<endl;
cout<<"4.矩阵的转置"<<endl;
cout<<"5.化阶梯型"<<endl;
cout<<"0.退出程序"<<endl;
int choice;
while(cin>>choice)
{
switch(choice)
{
case 1:
{
int size;
cout<<"请输入需要计算的行列式的维度数"<<endl;
cin>>size;
determinant jz(size);
jz.setdeterminant();
printf("该行列式的值为%.2lf\n",jz.equal());
break;
}
case 2:
{
int rc,col,row;//rc是矩阵A的行的最大值和B的列的最大值,col是矩阵A的列的最大值,row是矩阵B的行的最大值
cout<<"请输入矩阵A的行的最大值和B的列的最大值，矩阵A的列的最大值以及是矩阵B的行的最大值"<<endl;
cin>>rc>>col>>row;
matrix A(rc,col);
matrix B(row,rc);
cout<<"请为矩阵A赋值"<<endl;
A.setmatrix();
cout<<"请为矩阵B赋值"<<endl;
B.setmatrix();
matrix C;
multiplication(C,A,B);
C.show();
break;
}
case 3:
{
int size;
cout<<"请输入方阵的大小"<<endl;
cin>>size;
matrix inversing(size,size);
inversing.setmatrix();
inversing.transportation();
inversing.show();
break;
}
case 4:
{
int size;
cout<<"请输入方阵的大小"<<endl;
cin>>size;
matrix inversing(size,size);
inversing.setmatrix();
inversing.inverse();
inversing.show();
break;
}
case 5:
{
int m,n,R;
cout<<"请分别输入矩阵的列数和行数"<<endl;
cin>>m>>n;
matrix inversing(m,n);
inversing.setmatrix();
R=inversing.stairlize(0,m-1);
cout<<"该矩阵的秩为"<<R<<endl;
inversing.show();
break;
}
case 0:
exit(0);
break;
}
cout<<"请从新选择计算类型"<<endl;
}
}

/*
5
5 4
1 -2 2 -1 1
2 -4 8 0 2
-2 4 -2 3 3
3 -6 0 -6 4
*/

Answer 2

刚写好 的

#include <iostream>
using namespace std;
class CMyMatrix
{
public:
CMyMatrix()
{
memset(a,0,sizeof(a)); //初始化
}
void scanner(); //输入
CMyMatrix operator * (CMyMatrix &a); //重载乘法
CMyMatrix trans(CMyMatrix &a); //转置
void print(); //输出
private:
float a[4][4];

};
CMyMatrix CMyMatrix::trans(CMyMatrix &a)
{
CMyMatrix c;
for(int i=0;i<4;i++)
for(int j=0;j<4;j++)
{
c.a[i][j]=a.a[j][i];
}
return c;
}
void CMyMatrix::scanner()
{
for(int i=0;i<4;i++)
for(int j=0;j<4;j++)
cin>>a[i][j];

}
void CMyMatrix::print()
{
for(int i=0;i<4;i++)
for(int j=0;j<4;j++)
{
cout<<a[i][j]<<" ";
if(j==3)
cout<<endl;
}

}
CMyMatrix CMyMatrix::operator * (CMyMatrix &a)
{

CMyMatrix c;

for(int i=0;i<4;i++)
for(int j=0;j<4;j++)
for(int k=0;k<4;k++)
{
c.a[i][j]+=(*this).a[k][j]*a.a[i][k];

}

return c;

}
int main()
{
CMyMatrix a,b,c;
a.scanner();
b.scanner();
c=a*b;
c.print();
c=c.trans(c);
c.print();
return 0;
}