矩阵的转置和乘法课程设计程序
矩阵的转置和乘法课程设计程序
#ifndef CMatrix_H_//************************************************条件编译 #define CMatrix_H_
#include
#include
#include"vec.h"
//using namespace std;
#define MIN(a,b) ((a)
/*----------------------------------------定义类模板-------------------------------*/
template
class CMatrix
{
struct node
{
V ector **f;//*******************************************组成矩阵的向量指针
数
int refcnt;//*************************************************被引用次int length;//****************************************************矩阵
T **tmppointer;//*******************************************头指针类的行数
型
} *p; public: // V ector ** begin() const {return p->f;}; CMatrix();//***********************************************************默认的构造
CMatrix(int xsize,int ysize,T init=0);//*********************************构造函数
CMatrix(int xlength,const Vector *vec);//********************************构造函数
CMatrix(CMatrix &x); //***********************************************拷贝构造函数
~CMatrix();
//************************************************************析构函数
CMatrix & operator=(const CMatrix &mat);//*************************重载赋值运算符
int row() const;//*******************************************************返回行数
int col() const;//*******************************************************返回列数
V ector & operator
i);//******************************************重载[] []( int
void Inver(CMatrix &mat);//*********************************************矩阵转置
operator T **();//*********************************************************重载**
void ReadFromFile();//**************************************************从文件中读入矩阵
friend CMatrix cpy(CMatrix &v);//***********************************************拷贝函数
friend std::ostream & operator &mat);//重载输出函数
friend std::istream & operator>>(std::istream &s,const CMatrix &mat);//重载输入函数
friend CMatrix operator*(CMatrix &v1,CMatrix &v2);//***************矩阵乘法
friend CMatrix
//**********************数乘 operator*(const CMatrix &v,T val);
};
/*----------------------------------------类外定义缺省的构造函数----------------------------*/ template
CMatrix::CMatrix()
{
p=new node; p->length=NULL; p->f=0; p->refcnt=1;
p->tmppointer=NULL;
}
/*----------------------------------------定义可扩展构造函数------------------------*/
template
CMatrix::CMatrix(int xsize,int ysize,T init)
{
if(xsizelength=xsize; p->f=new Vector *[xsize]; for(int i(0);if[i]=new Vector(ysize,init); p->refcnt=1; p->tmppointer=NULL;
}
/*------------------------------------定义构造函数----------------------------*/
template
CMatrix::CMatrix(int xlength,const Vector *vec)
{
if(xlength
p=new node;
p->length=xlength;
p->f=new Vector *[xlength];
for(int i(0);if[i]=new Vector(*vec);
}
/*------------------------------------定义拷贝的构造函数-------------------------*/
template
CMatrix::CMatrix(CMatrix &x)
{
x.p->refcnt++;
p=x.p;
}
template
CMatrix cpy(CMatrix &v)
{
int mr=v.row(); int mc=v.col(); CMatrix x(mr,mc); for(int i(0);if[i])=*(v.p->f[i]); return x;
}
/*-----------------------------------定义析构函数-------------------------—*/
template
CMatrix::~CMatrix()
{
if(--p->refcnt==0) { if(p->f!=NULL) { } int len=p->length; for(int i(0);if[i]; if(p->tmppointer!=NULL) delete p->tmppointer; delete p->f;
}
}
/*------------------------------定义函数返回行数-----------------------*/
int CMatrix::row() const
{
return p->length;
}
/*----------------------------定义函数返回列数----------------------*/
template
int CMatrix::col() const
{
return p->f[0]->dim();
}
/*----------------------------定义转置的函数-----------------------*/
template
void Inver(CMatrix &mat)
{
int m = mat.row(); int n = mat.col(); CMatrix tmp(n,m); int i, j; for(i=0; i
for(j=0; j
}
mat=tmp;
}
/*---------------------------定义重载函数重载赋值操作符号=--------------------*/
template
CMatrix & CMatrix::operator=(const CMatrix &vec)
{
vec.p->refcnt++;
if(--p->refcnt==0) { } p=vec.p; int len=p->length; for(int i(0);if[i]; delete p->f; if(p->tmppointer!=NULL) delete p->tmppointer; delete p;
return *this;
}
/*-------------------------定义重载函数重载[]---------------------------*/
V ector &CMatrix::operator[](int i)
{
if((i>=0)&&(i
length))
return *p->f[i];
else{ } coutf[0];
}
/*--------------------------------定义重载函数重载**------------------*/
template
CMatrix::operator T **()
{
if(p->tmppointer==NULL){ int n=row(); } return p->tmppointer; p->tmppointer=new T *[n]; for(int i(0);itmppointer[i]=p->f[i]->begin();
}
template
void CMatrix::ReadFromFile()//******************************从文件中读入矩阵 {
//
//
//
char filename[256]; cin>>filename; ifstream infile; cout>row>>col; CMatrix v1(row,col,0); infile>>v1[0][0]; cout>v1[i][j]; *this=v1;
}
/*-----------------------定义函数重载输出《------------------------------*/
template
std::ostream & operator &v1)
{
// os
V ector **f=v1.begin();
// cout
int len=v1.row(); for(int i(0);i
return os;
}
/*-------------------------定义函数重载输入---------------------------*/
template
std::istream & operator>>(std::istream & is,CMatrix &v1)
{
int row,col;
cout
is>>row>>col; CMatrix x(row,col,0); cout>x[i][j];
return is;
}
/*--------------------------定义重载函数重载乘法*---------------------------*/
template
CMatrix operator*(CMatrix &m1,CMatrix &m2)
{
int i,j; int m1rows=m1.row(); int m1cols=m1.col(); int m2rows=m2.row(); int m2cols=m2.col(); if(m1cols!=m2rows) cout v(m1rows,m2cols); CMatrix flip(m2cols,m2rows); for(i=0;i
for(i=0;i
}
/*----------------------------------定义函数重载数乘（整型，双精度型）-------------------------------*/ CMatrix operator*(const CMatrix &v,int val)
{
CMatrix temp; temp=v; for(int i(0);ilength;i++) *(temp.p->f[i])=*(v.p->f[i])*val; return temp;
}
CMatrix operator*(const CMatrix &v,double val)
{
CMatrix temp; temp=v; for(int i(0);ilength;i++) *(temp.p->f[i])=*(v.p->f[i])*val;
return temp;
}
#endif
/*---------------------------------------------------定义几个选择函数----------------------------------------*/
void choiceid();//********************************************选择输入矩阵的类型 void processint();//*****************************************选择输入矩阵的饿方式 void processdouble();//***************************************选择输入矩阵的方式 template
void process(CMatrix &cm,CMatrix &cm1,CMatrix &cm2);
void main()
{
cout
choiceid();
}
/*---------------------------------------------------------
-----------------------------------------*/
void choiceid()
{ 定义选择函数
cout>choice; switch(choice) { case 1: processint(); break; case 2: processdouble(); break; default: } break;
}
void processint()
{
CMatrix icm(2,2,0),icm1,icm2; cout>choice) { switch(choice) { case 1: cout>icm1; cout>icm2; process(icm,icm1,icm2);
break;
case 2:
cout
icm1.ReadFromFile();
cout
icm2.ReadFromFile(); process(icm,icm1,icm2); break; default: } break;
}
}
void processdouble()
{
CMatrix icm,icm1,icm2; cout>choice) { switch(choice) { case 1: cout>icm1; cout>icm2; process(icm,icm1,icm2); break; case 2: cout
icm1.ReadFromFile();
cout
} } icm2.ReadFromFile(); process(icm,icm1,icm2); break; default: break; }
template
void process(CMatrix &cm,CMatrix &cm1,CMatrix &cm2)
{
int choice;
double val;
cout
while(cin>>choice) { switch(choice) { case 1: cm=cm1*cm2; cout>choice;
if(choice==1){cout
if(choice==2)
{
cout
continue; };break; case 2: cout>val; cout>choice; switch(choice) {
case 1:
cm=cm1*val;
cout
cin>>choice; if(choice==1){cout
{
cout
continue; }; break; case 2: cm=cm2*val; cout>choice; if(choice==1){cout
case 3:
cout
while(cin>>choice){
if(choice==1){ Inver(cm1); cout>choice; if(choice==1){cout
if(choice==2)
{
cout
continue;
}; 矩阵数乘\n3.矩阵转置\n";
} default: exit(0); }
}
/*--------------------------------------------程序结束了！