矩阵类 重载.docx
《矩阵类 重载.docx》由会员分享，可在线阅读，更多相关《矩阵类 重载.docx（13页珍藏版）》请在冰豆网上搜索。
矩阵类重载
/***设计一个矩阵（摸板）类Matrix,实现矩阵的输入和输出（重载>>和<<）,重载拷贝构造函数，
赋值运算和函数调用运算符（）实现矩阵的转置!
、加、减、乘和求负-，必须处理各种异常
（越界、下标错误、不匹配等）然后编写主函数进行全面的测试。
*********************/
/****************************************************************************************************/
#include
#include//getch原型
usingnamespacestd;
//空间申请异常类
classWrongmem{};
//下标越界异常类
classOutofrange{};
//定义错误异常类
classDiffer{};
/*********************************矩阵类开始**************************************/
constintMAX_SIZE=1000;
template
classMatrix
{
public:
//两参数构造函数
Matrix（intr,intc）:
rows（r）,cols（c）
{
if（rows>MAX_SIZE||rows<1||cols>MAX_SIZE||cols<1）throwOutofrange（）;
mem=newT[rows*cols];
if（mem==NULL）throwOutofrange（）;
}
//四参数构造函数
Matrix（intr,intc,T*data,intsize=0）:
rows（r）,cols（c）
{
if（rows>MAX_SIZE||rows<1||cols>MAX_SIZE||cols<1）throwOutofrange（）;
if（size&&sizemem=newT[rows*cols];
if（mem==NULL）throwWrongmem（）;
for（inti=0;imem[i]=data[i];
}
//析构函数
~Matrix（）{delete[]mem;}
Tsetrows（）const{returnrows;}
Tsetcols（）const{returncols;}
//修改矩阵
voidsetMatrix（T*data,intsize）;
voidsetMatrix（T*data）;
//重载函数调用运算符（）
T&operator（）（inti,intj）;
//拷贝构造函数
Matrix（constMatrix&x）;
//重载赋值运算符
Matrixoperator=（Matrix&x）;
//重载转置!
Matrixoperator!
（）;
//重载+
Matrixoperator+（constMatrix&x）;
//重载-
Matrixoperator-（constMatrix&x）;
//重载*
Matrixoperator*（constMatrix&x）;
//重载求负-
Matrixoperator-（）;
private:
T*mem;
constintrows,cols;
};
/**************************函数实现**********************************/
//修改矩阵
template
voidMatrix:
:
setMatrix（T*data,intsize）
{
if（rows*cols>size）throwOutofrange（）;
for（inti=0;imem[i]=data[i];
}
template
voidMatrix:
:
setMatrix（T*data）
{
for（inti=0;imem[i]=data[i];
}
//重载函数调用运算符（）
template
T&Matrix:
:
operator（）（inti,intj）
{
if（i>=rows||j>=cols）throwOutofrange（）;
elsereturnmem[i*cols+j];
}
//重载输入运算符
template
istream&operator>>（istream&in,Matrix&x）
{
for（inti=0;i{
for（intj=0;jin>>x（i,j）;
}
returnin;
}
//重载输出<<
template
ostream&operator<<（ostream&out,Matrix&x）
{
for（inti=0;i{
for（intj=0;jout<out<}
out<returnout;
}
//拷贝构造函数
template
Matrix:
:
Matrix（constMatrix&x）:
rows（x.rows）,cols（x.cols）
{
mem=newT[rows*cols];
if（mem==NULL）throwDiffer（）;
else
for（inti=0;imem[i]=x.mem[i];
}
//重载附值运算符=
template
MatrixMatrix:
:
operator=（Matrix&x）
{
if（rows!
=x.rows||cols!
=x.cols）throwDiffer（）;
if（this!
=&x）
{
delete[]mem;
mem=newT[rows*cols];
if（mem==NULL）throwWrongmem（）;
else
for（inti=0;imem[i]=x.mem[i];
}
return*this;
}
//重载转置!
template
MatrixMatrix:
:
operator!
（）
{
Matrixtemp（cols,rows）;
for（inti=0;ifor（intj=0;jtemp（i,j）=（*this）（j,i）;
returntemp;
}
//重载+
template
MatrixMatrix:
:
operator+（constMatrix&x）
{
inti;
if（rows!
=x.rows||cols!
=x.cols）throwDiffer（）;
Matrixtemp（*this）;
if（rows==x.rows&&cols==x.cols）
{
for（i=0;itemp.mem[i]=mem[i]+x.mem[i];
returntemp;
}
elsethrowDiffer（）;
}
//重载-
template
MatrixMatrix:
:
operator-（constMatrix&x）
{
inti;
if（rows!
=x.rows||cols!
=x.cols）throwDiffer（）;
Matrixtemp（*this）;
if（rows==x.rows&&cols==x.cols）
{
for（i=0;itemp.mem[i]=mem[i]-x.mem[i];
returntemp;
}
elsethrowDiffer（）;
}
wanfustudio-雁南飞：
知识之败,慕虚名而不务潜修也at2007-10-27>
#3
//重载矩阵乘法运算符*
template
MatrixMatrix:
:
operator*（constMatrix&x）
{
if（cols!
=x.rows）throwDiffer（）;
Matrixtemp（rows,x.cols）;
for（inti=0;ifor（intj=0;j{
temp（i,j）=0;
for（intk=0;ktemp（i,j）+=mem[i*cols+k]*x.mem[k*x.cols+j];
}
returntemp;
}
//重载求负-
template
MatrixMatrix:
:
operator-（）
{
Matrixtemp（*this）;
for（inti=0;itemp.mem[i]=（-1）*mem[i];
returntemp;
}
/**************************主函数开始***************************/
voidmain（）
{
try{
//矩阵的行和列必须在1和MAX_SIZE之间
Matrixm0（0,3）;
}
catch（...）{
cout<<"执行语句Matrixm0（0,3）;导致矩阵的大小错误!
\n";
}
try{
//矩阵的行和列必须在1和MAX_SIZE之间
Matrixmax（MAX_SIZE+1,3）;
}
catch（...）{
cout<<"执行语句Matrixmax（"<<<",3）;导致矩阵的大小错误!
\n";
}
cout<//定义3行3列的空矩阵m1
Matrixm1（3,3）;
cout<<"InputMatrixm1（3,3）:
\n";
//利用已重载的输入运算符>>输入矩阵
cin>>m1;
//利用已重载的输出运算符<<输出矩阵
cout<<"Matrixm1（3,3）:
\n"<//利用拷贝构造函数构造矩阵m2（3行3列）
Matrixm2（m1）;
cout<<"Matrixm2（m1）:
\n"<inta[]={9,8,7,6,5,4,3,2,1};
/****************************************************************
**定义3行3列的空矩阵m3,并用数组a进行初始化**
**等价于下述语句：
**
**Matrixm3（3,3,a,sizeof（a）/sizeof（int））;**
**构造函数的最后一个参数为数组的长度，默认值为0**
**当数组长度参数非0时将进行数组长度和矩阵元素个数的匹配检查!
**
****************************************************************/
Matrixm3（3,3,a）;
cout<<"Matrixm3（3,3,a）:
\n"<m3=-m1;//求负（矩阵所有元素取相反值）
cout<<"Matrixm3=-m1:
\n"<m3=m1=m1;//与C++一样允许连续赋值!
cout<<"Matrixm3=m1=m1:
\n"<cout<cout<<"按任意键继续.....\n";
getch（）;
cout<//矩阵转置，等价于：
m2=m1.transpose（）;
m2=!
m1;
cout<<"Matrixm2=!
m1:
\n"<m2.setMatrix（a）;//用数组a修改矩阵m2各元素的值
cout<<"Matrixm2.setMatrix（a）:
\n"<m2=m1+m1;//矩阵加
cout<<"Matrixm2=m1+m1:
\n"<m3=m1*m2;//矩阵乘
cout<<"Matrixm3=m1*m2:
\n"<m3=m3-m2;//矩阵减
cout<<"Matrixm3=m3-m2:
\n"<cout<cout<<"按任意键继续.....\n";
getch（）;
cout<Matrixm4（4,5）,m5（5,4）;
//利用已重载的运算符（）直接给矩阵m4赋值
for（inti=0;ifor（intj=0;jm4（i,j）=（i+1）*（j+1）;
cout<<"Matrixm4:
\n"<try{
//m4矩阵空间大于存放矩阵m3所有元素的空间
m4=m3;
cout<<"Matrixm4=m3:
\n"<//允许元素个数不相同的矩阵进行赋值!
//只要求目标矩阵的容量足够存放源矩阵的所有元素就允许赋值!
}
catch（...）{
cout<<"\n执行语句m4=m3;导致矩阵的大小错误异常!
\n\n";
//不允许元素个数不相同的矩阵进行赋值时输出该信息!
}
intb[]={0,1,2,3,4,5,6,7,8,9,9,8,7,6,5,4,3,2,1,0};
//用数组b修改矩阵m4各元素的值,同时进行个数匹配检查
m4.setMatrix（b,sizeof（b）/sizeof（int））;
cout<<"m4.setMatrix（b,"<\n"<//重载运算符!
实现矩阵转置,与成员函数transpose（）功能一致!
m5=!
m4;
cout<<"Matrixm5=!
m4:
\n"<cout<cout<<"按任意键继续.....\n";
getch（）;
cout<cout<<"Matrixm5*m4:
\n"<cout<<"Matrixm4*m5:
\n"<cout<try{
//第1个矩阵的列数不等于第2个矩阵的行数
cout<}
catch（...）{
cout<<"执行语句cout<\n";
}
try{
//超过矩阵m4的最大行、列数
for（i=0;i<=m4.setrows（）;++i）
for（intj=0;j<=m4.setcols（）;++j）
m4（i,j）=（i+1）*（j+1）;
}
catch（...）{
cout<<"执行上述程序段将导致下标（访问）越界异常!
\n\n";
}
try{
//数组长度不足于给矩阵m4的所有元素赋值
m4.setMatrix（a,sizeof（a）/sizeof（int））;
}
catch（...）{
cout<<"执行语句m4.setMatrix（a,"<<<"）;导致数组长度不足异常!
\n";
}
try{
//虽然数组b有足够的元素，但指定的长度小于矩阵m4的元素个数
m4.setMatrix（b,15）;
}
catch（...）{
cout<<"执行语句m4.setMatrix（b,15）;导致数组长度不足异常!
\n";
}
try{
//m3矩阵不足于存放矩阵m4的所有元素
m3=m4;
}
catch（...）{
cout<<"执行语句m3=m4;导致矩阵的大小错误异常!
\n";
}
try{
//第1个矩阵的列数必须等于第2个矩阵的行数才能相乘
m3=m1*m4;
}
catch（...）{
cout<<"执行语句m3=m1*m4;导致矩阵的大小错误异常!
\n";
}
try{
//两个矩阵的行数和列数必须完全一致才能相加
m3=m4+m1;
}
catch（...）{
cout<<"执行语句m3=m4+m1;导致矩阵的大小错误异常!
\n";
}
try{
//两个矩阵的行数和列数必须完全一致才能相减
m3=m4-m1;
}
catch（...）{
cout<<"执行语句m3=m4-m1;导致矩阵的大小错误异常!
\n";
}
cout<}
升级会员 