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