Question

C++程序设计实现一个矩阵类（一般矩阵，行数和列数不一定相等）

实现一个矩阵类（一般矩阵，行数和列数不一定相等）。功能包括：
1、包括一个默认的构造函数
2、包括一个带参的构造函数，
2、包括一个拷贝构造函数
3、编写一个求矩阵逆的成员函数（如果矩阵是方阵而且非奇异）
4、编写一个求矩阵行列式的成员函数（如果矩阵是方阵）
5、编写一个判断矩阵是否奇异的成员函数

Answer 1

//以下是我原来作业写的,没怎么写注释
//你可以参考一下.
#include <iostream>
using namespace std;
/************************/
/********矩阵结构********/
/************************/
class Juz
{
public:
Juz(int l,int w,int *n);
Juz();
Juz(Juz &jz);
void setnum(int l,int w);
Juz operator+(const Juz &jz);
Juz operator-(const Juz &jz);
Juz operator*(const Juz &jz);
Juz operator=(const Juz &jz);
Juz zhuanzhi();
void show();
~Juz();
static int getflag()
private:
int *num;
int length;
int width;
static int flag;//为0表示无操作，1为操作成功
};
int Juz::flag=0;
/************************/
/********构造函数********/
/************************/
Juz::Juz(int l,int w,int *n)
{
length=l;
width=w;
num=new int[length*width];
int *p=num;
for(int i=0;i<length*width;i++)
{
*p++=*n++;
}
}

/************************/
/******默认构造函数******/
/************************/
Juz::Juz()
{
length=1;
width=1;
num=new int(1);
}
/************************/
/********构造函数********/
/************************/
Juz::Juz(Juz &jz)
{
length=jz.length;
width=jz.width;
num=new int[length*width];
for(int i=0;i<length*width;i++)
{
*(num+i)=*(jz.num+i);
}
}

/************************/
/********输入矩阵********/
/************************/
void Juz::setnum(int l,int w)
{
length=l;
width=w;
if(l==0||w==0)
{
cout<<"矩阵行列不能为0"<<endl;
return ;
}
else
{
delete[]num;
num=NULL;
num=new int[length*width];
int *p=num;
cout<<length<<"*"<<width<<"矩阵:"<<endl;
for(int i=0;i<length;i++)
{
cout<<"请输入第"<<i+1<<"行元素:"<<endl;
for(int j=0;j<width;j++)
{

cout<<"第"<<j+1<<"列元素:";
cin>>*(p+i*width+j);
}
}
}
}
/************************/
/********矩阵加法********/
/************************/
Juz Juz::operator +(const Juz &jz)
{
if(length==jz.length && width==jz.width)
{
flag=1;
int *n=new int[length*width];
for(int i=0;i<length*width;i++)
{
*(n+i)=*(num+i)+*(jz.num+i);
}
Juz temp(length,width,n);
if(length*width>1)
{
delete[]n;
}
else
{
delete n;
}
return temp;
}
else
{
Juz temp;
flag=0;
return temp;
}
}
/************************/
/********矩阵减法********/
/************************/
Juz Juz::operator -(const Juz &jz)
{
if(length==jz.length && width==jz.width)
{
flag=1;
int *n=new int[length*width];
for(int i=0;i<length*width;i++)
{
*(n+i)=*(num+i)-*(jz.num+i);
}
Juz temp(length,width,n);
if(length*width==1)
{
delete n;
}
else
{
delete []n;
}
return temp;
}
else
{
flag=0;
Juz temp;
return temp;
}
}
/************************/
/********矩阵乘法********/
/************************/
Juz Juz::operator*(const Juz &jz)
{
if(width==jz.length)
{
flag=1;
int *n=new int[length*jz.width];
int i=0;
int j=0;
int t=0;
for(i=0;i<length;i++)
{
for(j=0;j<jz.width;j++)
{
*(n+i*jz.width+j)=0;
}
}
for(i=0;i<length;i++)
{
for(j=0;j<width;j++)
{
for(t=0;t<jz.width;t++)
{
*(n+i*jz.width+t)+=*(num+i*width+j)**(jz.num+j*jz.width+t);
}
}
}
Juz temp(length,jz.width,n);
if(length*jz.width==1)
{
delete n;
}
else
{
delete [] n;
}
return temp;
}
else
{
flag=0;
Juz temp;
return temp;
}
}
/************************/
/********矩阵赋值********/
/************************/
Juz Juz::operator =(const Juz &jz)
{
if(width*length==1)
{
delete num;
}
else
{
delete [] num;
}
length=jz.length;
width=jz.width;
num=new int[jz.length*jz.width];
for(int i=0;i<length;i++)
{
for(int j=0;j<width;j++)
{
*(num+i*width+j)=*(jz.num+i*jz.width+j);
}
}
return *this;
}

/************************/
/********矩阵转置********/
/************************/
Juz Juz::zhuanzhi()
{
flag=1;
int *n=new int[length*width];
for(int i=0;i<length;i++)
{
for(int j=0;j<width;j++)
{
*(n+j*length+i)=*(num+i*width+j);
}
}
Juz temp(width,length,n);
if(length*width==1)
{
delete n;
}
else
{
delete [] n;
}
return temp;
}

/************************/
/******打印矩阵函数******/
/************************/
void Juz::show()
{
if(length*width!=0)
{
for(int i=0;i<length*width;i++)
{
cout.width(5);
cout<<*(num+i);
if((i+1)%width==0)
{
cout<<endl;
}
}
}
}

/************************/
/********矩阵维数********/
/************************/
void getmn(int &m,int &n)
{
while(1)
{
cout<<"请输入矩阵维数:"<<endl;
cout<<"行数:";
cin>>m;
cout<<"列数:";
cin>>n;
if(m>0&&n>0)
{
return;
}
}
}

/************************/
/********析构函数********/
/************************/
Juz::~Juz()
{
if(length*width==1)
{
delete num;
}
else
{
delete [] num;
}
}

int main()
{
Juz j1,j2,j3;
int m,n;
getmn(m,n);
j1.setnum(m,n);
j3=j1.zhuanzhi();
if(Juz::getflag()==1)
{
cout<<"1:"<<endl;
j1.show();
cout<<"2:"<<endl;
j2.show();
cout<<"3:"<<endl;
j3.show();
}
return 0;
}

Answer 2

//以下是我原来作业写的,没怎么写注释
//你可以参考一下.
#include <iostream>
using namespace std;
/************************/
/********矩阵结构********/
/************************/
class Juz
{
public:
Juz(int l,int w,int *n);
Juz();
Juz(Juz &jz);
void setnum(int l,int w);
Juz operator+(const Juz &jz);
Juz operator-(const Juz &jz);
Juz operator*(const Juz &jz);
Juz operator=(const Juz &jz);
Juz zhuanzhi();
void show();
~Juz();
static int getflag()
private:
int *num;
int length;
int width;
static int flag;//为0表示无操作，1为操作成功
};
int Juz::flag=0;
/************************/
/********构造函数********/
/************************/
Juz::Juz(int l,int w,int *n)
{
length=l;
width=w;
num=new int[length*width];
int *p=num;
for(int i=0;i<length*width;i++)
{
*p++=*n++;
}
}

/************************/
/******默认构造函数******/
/************************/
Juz::Juz()
{
length=1;
width=1;
num=new int(1);
}
/************************/
/********构造函数********/
/************************/
Juz::Juz(Juz &jz)
{
length=jz.length;
width=jz.width;
num=new int[length*width];
for(int i=0;i<length*width;i++)
{
*(num+i)=*(jz.num+i);
}
}

/************************/
/********输入矩阵********/
/************************/
void Juz::setnum(int l,int w)
{
length=l;
width=w;
if(l==0||w==0)
{
cout<<"矩阵行列不能为0"<<endl;
return ;
}
else
{
delete[]num;
num=NULL;
num=new int[length*width];
int *p=num;
cout<<length<<"*"<<width<<"矩阵:"<<endl;
for(int i=0;i<length;i++)
{
cout<<"请输入第"<<i+1<<"行元素:"<<endl;
for(int j=0;j<width;j++)
{

cout<<"第"<<j+1<<"列元素:";
cin>>*(p+i*width+j);
}
}
}
}
/************************/
/********矩阵加法********/
/************************/
Juz Juz::operator +(const Juz &jz)
{
if(length==jz.length && width==jz.width)
{
flag=1;
int *n=new int[length*width];
for(int i=0;i<length*width;i++)
{
*(n+i)=*(num+i)+*(jz.num+i);
}
Juz temp(length,width,n);
if(length*width>1)
{
delete[]n;
}
else
{
delete n;
}
return temp;
}
else
{
Juz temp;
flag=0;
return temp;
}
}
/************************/
/********矩阵减法********/
/************************/
Juz Juz::operator -(const Juz &jz)
{
if(length==jz.length && width==jz.width)
{
flag=1;
int *n=new int[length*width];
for(int i=0;i<length*width;i++)
{
*(n+i)=*(num+i)-*(jz.num+i);
}
Juz temp(length,width,n);
if(length*width==1)
{
delete n;
}
else
{
delete []n;
}
return temp;
}
else
{
flag=0;
Juz temp;
return temp;
}
}
/************************/
/********矩阵乘法********/
/************************/
Juz Juz::operator*(const Juz &jz)
{
if(width==jz.length)
{
flag=1;
int *n=new int[length*jz.width];
int i=0;
int j=0;
int t=0;
for(i=0;i<length;i++)
{
for(j=0;j<jz.width;j++)
{
*(n+i*jz.width+j)=0;
}
}
for(i=0;i<length;i++)
{
for(j=0;j<width;j++)
{
for(t=0;t<jz.width;t++)
{
*(n+i*jz.width+t)+=*(num+i*width+j)**(jz.num+j*jz.width+t);
}
}
}
Juz temp(length,jz.width,n);
if(length*jz.width==1)
{
delete n;
}
else
{
delete [] n;
}
return temp;
}
else
{
flag=0;
Juz temp;
return temp;
}
}
/************************/
/********矩阵赋值********/
/************************/
Juz Juz::operator =(const Juz &jz)
{
if(width*length==1)
{
delete num;
}
else
{
delete [] num;
}
length=jz.length;
width=jz.width;
num=new int[jz.length*jz.width];
for(int i=0;i<length;i++)
{
for(int j=0;j<width;j++)
{
*(num+i*width+j)=*(jz.num+i*jz.width+j);
}
}
return *this;
}

/************************/
/********矩阵转置********/
/************************/
Juz Juz::zhuanzhi()
{
flag=1;
int *n=new int[length*width];
for(int i=0;i<length;i++)
{
for(int j=0;j<width;j++)
{
*(n+j*length+i)=*(num+i*width+j);
}
}
Juz temp(width,length,n);
if(length*width==1)
{
delete n;
}
else
{
delete [] n;
}
return temp;
}

/************************/
/******打印矩阵函数******/
/************************/
void Juz::show()
{
if(length*width!=0)
{
for(int i=0;i<length*width;i++)
{
cout.width(5);
cout<<*(num+i);
if((i+1)%width==0)
{
cout<<endl;
}
}
}
}

/************************/
/********矩阵维数********/
/************************/
void getmn(int &m,int &n)
{
while(1)
{
cout<<"请输入矩阵维数:"<<endl;
cout<<"行数:";
cin>>m;
cout<<"列数:";
cin>>n;
if(m>0&&n>0)
{
return;
}
}
}

/************************/
/********析构函数********/
/************************/
Juz::~Juz()
{
if(length*width==1)
{
delete num;
}
else
{
delete [] num;
}
}

int main()
{
Juz j1,j2,j3;
int m,n;
getmn(m,n);
j1.setnum(m,n);
j3=j1.zhuanzhi();
if(Juz::getflag()==1)
{
cout<<"1:"<<endl;
j1.show();
cout<<"2:"<<endl;
j2.show();
cout<<"3:"<<endl;
j3.show();
}
return 0;
}
我可以帮助你，你先设置我最佳答案后，我百度Hii教你。

Answer 3

#include <iostream>
#include <math.h>
using namespace std;
class Cmatrix
{
public:
Cmatrix();
Cmatrix(Cmatrix &x);
Cmatrix(int i,int j,double a[]);
~Cmatrix();

double getA(int,int);//得到矩阵元素
int getH();
int getL();
double* getpt();
double getHL_value();//计算行列式的值
bool isOdd();//奇异矩阵
Cmatrix inv();//求逆
void setpt(double*);//设置矩阵元素值
Cmatrix T();//转置

private:
int H; //矩阵行数
int L;//矩阵列数
double* pt;//矩阵的值，以一维数组的形式存放

};

Cmatrix::Cmatrix()
{
H=0;
L=0;
pt=NULL;
}

Cmatrix::Cmatrix(int i,int j,double a[])
{
H=i;
L=j;
pt=a;

}

Cmatrix::~Cmatrix()
{

}

void Cmatrix::setpt(double* p)
{
pt=p;
}
bool Cmatrix::isOdd()
{
if (abs (getHL_value()) < 0.000000001) return true;else return false;
}
double* Cmatrix::getpt()
{
return pt;
}

int Cmatrix::getH()
{
return H;
}

int Cmatrix::getL()
{
return L;
}

double Cmatrix::getA(int i,int j)
{
//return *(pt+(i-1)*H+(j-1));
return pt[(i-1)*H+(j-1)];
}

Cmatrix::Cmatrix(Cmatrix &x)
{
pt=new double[x.getH()*x.getL()];
long i;
for (i=0;i<x.getH()*x.getL();i++)
{
pt[i]=x.getpt()[i];
}
H=x.getH();
L=x.getL();

}

Cmatrix Cmatrix::T()
{
Cmatrix temp(L,H,NULL);
double *p;
p=new double[H*L];
int i,j;
for (i=0;i<L;i++)
{
for (j=0;j<H;j++)
{
p[i*H+j]=pt[j*L+i];
}
}
temp.setpt(p);
p=NULL;
return temp;
}

double Cmatrix::getHL_value()
{

double max,temp,a;
double num=1;
double *p;
p=new double[H*H];
int maxid;
int i,j,k,s,n;
int flag=1;

for(i=0;i<H*H;i++)
{
p[i]=pt[i];
}

for(i=0;i<H-1;i++)
{
max=fabs(p[i*H+i]);
maxid=i;
for(s=i+1;s<=H-1;s++)
{
if(fabs(p[s*H+i])>max)
{
max=fabs(p[s*H+i]);
maxid=s;
}
}

if(max==0)
return 0;

if(maxid!=i)
{ flag=flag*(-1);
for(n=i;n<=H-1;n++)
{
temp=p[maxid*H+n];
p[maxid*H+n]=p[i*H+n];
p[i*H+n]=temp;
}

}

for(j=i+1;j<=H-1;j++)
{
a=-p[j*H+i]/p[i*H+i];
for(k=i;k<=H-1;k++)
{
p[j*H+k]=p[j*H+k]+a*p[i*H+k];
}

}

}

for(i=0;i<=H-1;i++)
{
num=num*p[i*H+i];

}
delete []p;
return flag*num;

}

Cmatrix Cmatrix::inv()
{
int i,j,k,n;
int chax=0,chay=0;
double add;
double *p;
double *q;
p=new double[H*H];
q=new double[(H-1)*(H-1)];
Cmatrix temp1(H,H,NULL);
Cmatrix temp2(H-1,H-1,NULL);
add=1/this->getHL_value();

for(k=0;k<H;k++)
{
for(n=0;n<H;n++)
{

for(i=0;i<H-1;i++)
{
if(i<k)
chax=0;
else
chax=1;
for(j=0;j<H-1;j++)
{
if(j<n)
chay=0;
else
chay=1;
q[i*(H-1)+j]=pt[(i+chax)*H+(j+chay)];
}

}

temp2.setpt(q);
p[n*H+k]=pow(-1.0,k+n)*add*temp2.getHL_value();

}
}
temp1.setpt(p);
delete []q;
return temp1;

}