矩阵类

最新推荐文章于 2021-09-23 23:29:44 发布

QQ_370566617

最新推荐文章于 2021-09-23 23:29:44 发布

阅读量2.7k

点赞数 2

分类专栏：图像处理/Image Process 理论与算法Algorithm 源码模块/Source Code 文章标签： delete matrix null iostream constructor float

本文链接：https://blog.csdn.net/begtostudy/article/details/1448216

版权

图像处理/Image Process 同时被 3 个专栏收录

49 篇文章 0 订阅

订阅专栏

源码模块/Source Code

30 篇文章 0 订阅

订阅专栏

理论与算法Algorithm

19 篇文章 0 订阅

订阅专栏

此次的矩阵类可以使用双下标，并且带有越界检查能力

用例：

jks::CMatrix<int> m(3,4);
int i,j;
for (i=0;i<m.getHeight();i++)
{
  for (j=0;j<m.getWidth();j++)
  {
   m[i][j] = i*10+j;
  }
}

cerr<<m;

=========================================================================

头文件

#if !defined(__JKS_MATRIX_HPP_)
#define __JKS_MATRIX_HPP_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

#include <cassert>
#include <iostream>
namespace jks
{
//

template<typename T>
class CMatrix
{
class CLine
{
T* _pLine;
CMatrix* _pMat;

public:
CLine(T* pLine,CMatrix* pMat):_pLine(pLine),_pMat(pMat) {};
T& operator[] (long nCol)
{assert(nCol>=0 && nCol<_pMat->getWidth());return _pLine[nCol];}

};

long _sLn,_sCol;
T* _pData;
public:
CMatrix();
CMatrix(T * arrAddress,long arrWidth);//构造一维矩阵(一行，arrWidth列)
CMatrix(T * arrAddress,long arrHeight,long arrWidth);//构造二维矩阵
CMatrix(long Height,long Width);//构造空矩阵
CMatrix(const CMatrix<T> &);//复制构造函数
virtual ~CMatrix(void);//默认析构函数

//属性
long getHeight() const {return _sLn; }
long getWidth() const {return _sCol;}
T* getData(long& arrHeight,long& arrWidth,T* p=NULL) const;
T* getData(int& arrHeight,int& arrWidth,T* p=NULL) const
{long t1 = arrHeight;long t2 = arrWidth;
arrHeight = _sLn;arrWidth = _sCol;
return getData(t1,t2,p);}

operator void* () {return isValid()?this:0;}
bool isValid() const
{
  if(this!=NULL && _pData!=NULL) return true;
  else return false;
}
bool isInDomain(long nLn,long nCol)
{
  if (nLn<_sLn && nLn>=0 && nCol<_sCol && nCol>=0)
   return true;
  else
   return false;
}
int isVector();//如果是0，那就是一个数;1,列向量;-1行向量

//运算
CMatrix operator+(CMatrix<T> &);
CMatrix operator-(CMatrix<T> &);
CMatrix operator*(CMatrix<T> &);
friend CMatrix operator*(double alpha,CMatrix<T> &);//实数与矩阵相乘
CMatrix operator*(double alpha);//矩阵与实数相乘
CMatrix operator/(CMatrix<T> &);//实际是实数相除或矩阵和实数相除
CMatrix operator/(double sub);
CMatrix operator+=(CMatrix<T> &);
CMatrix operator-=(CMatrix<T> &);
CMatrix operator*=(CMatrix<T> &);//矩阵与实数相乘
CMatrix operator*=(double alpha);//矩阵与实数相乘
CMatrix & operator = (CMatrix<T> &);//赋值
CLine operator[](long heightPos);//用于实现用[][]操作矩阵元素
friend CMatrix sqrt(CMatrix<T> m);//开方
friend double abs(CMatrix<T> &);//取绝对值(泛数)
friend double sum(CMatrix<T> &);//求和
friend CMatrix multiply(CMatrix<T> &m1,CMatrix<T> & m2);//按元素相乘
friend T operator+(double dbl,CMatrix<T> &);
friend T operator+(CMatrix<T> &,double dbl);
friend T operator-(double dbl,CMatrix<T> &);
friend T operator-(CMatrix<T> &,double dbl);
const T* c_ptr() const;
friend bool operator == (CMatrix<T> &,CMatrix<T> &);

//输出
friend std::ostream& operator<<(std::ostream &,jks::CMatrix<T> &);

public:
//公有属性
static float m_fPrecision;//控制==的精度
static double m_dPrecision;

};

//
//函数实现
template<typename T>
float CMatrix<T>::m_fPrecision = 0.0000001;
template<typename T>
double CMatrix<T>::m_dPrecision = 1e-20;

//
//构造与析构
template<typename T>
CMatrix<T>::CMatrix(void)//:_sCol(1),_sLn(1)
{
_sCol = 0;
_sLn = 0;
_pData=NULL;
}

template<typename T>
CMatrix<T>::CMatrix(T * arrAddress,long arrWidth)
{
long arrHeight=1;
_pData=new T[arrWidth*arrHeight];
memcpy(_pData,arrAddress,arrWidth*arrHeight*sizeof(T));

_sCol=arrWidth;
_sLn=arrHeight;
}

template<typename T>
CMatrix<T>::CMatrix(T * arrAddress,long arrHeight,long arrWidth)
{
_pData=new T[arrWidth*arrHeight];
memcpy(_pData,arrAddress,arrWidth*arrHeight*sizeof(T));

_sCol=arrWidth;
_sLn=arrHeight;
}

template<typename T>
CMatrix<T>::CMatrix(long height,long width)
{
_sCol=width;
_sLn=height;
_pData=new T[height*width];
}

template<typename T>
CMatrix<T>::CMatrix(const CMatrix<T> & m)//copy constructor
{
_sLn=m._sLn;
_sCol=m._sCol;

_pData=new T[_sLn*_sCol];
memcpy(_pData,m._pData,_sLn*_sCol*sizeof(T));
}

template<typename T>
CMatrix<T>::~CMatrix()
{
if (_pData)
{
delete []_pData;
}
_pData = NULL;

_sLn = 0;
_sCol = 0;

}

//
//运算

template<typename T>
CMatrix<T> CMatrix<T>::operator +(CMatrix &m1)
{
assert(m1._sLn==_sLn && m1._sCol==_sCol);
long tmpHeight=m1._sLn;
long tmpWidth=m1._sCol;
T * t=new T[tmpWidth*tmpHeight];
for(long i=0;i<tmpHeight;i++){
for(long j=0;j<tmpWidth;j++){
*(t+tmpWidth*i+j)=*((T*)m1._pData+tmpWidth*i+j)+*((T*)_pData+tmpWidth*i+j);
}
}
CMatrix<T> m(t,tmpHeight,tmpWidth);
delete [] t;
return m;
}

template<typename T>
CMatrix<T> CMatrix<T>::operator -(CMatrix &m1)
{
assert(m1._sLn==_sLn && m1._sCol==_sCol);
long tmpHeight=m1._sLn;
long tmpWidth=m1._sCol;
T * t=new T[tmpWidth*tmpHeight];
for(long i=0;i<tmpHeight;i++){
for(long j=0;j<tmpWidth;j++){
*(t+tmpWidth*i+j)=*((T*)_pData+tmpWidth*i+j)-*((T*)m1._pData+tmpWidth*i+j);
}
}
CMatrix<T> m(t,tmpHeight,tmpWidth);
delete [] t;
return m;
}

template<typename T>
CMatrix<T> CMatrix<T>::operator *(CMatrix &m1)
{
if(!this->isVector() && m1.isVector()){//左为数,右为矩阵
CMatrix<T> m;
   m=((T*)_pData)[0]*m1;
return m;
}else if(this->isVector() && !m1.isVector()){//左为矩阵,右为数
CMatrix m;
   m=*this*m1[0][0];
return m;
}else if(!this->isVector() && m1.isVector()){//左右都为数
T * t=new T[1];
t[0]=((T*)_pData)[0]*m1[0][0];
CMatrix<T> m(t,1,1);
delete [] t;
return m;
}else if(this->isVector() && m1.isVector() && _sCol==m1._sLn){//左为矩阵,右为矩阵
double sum;
T * t=new T[_sLn*m1._sCol];
for(long i=0;i<_sLn;i++){
   for(long j=0;j<m1._sCol;j++){
    sum=0;
    for(long k=0;k<_sCol;k++){
     sum+=(*((T*)_pData+_sCol*i+k))*(m1[k][j]);
    }
    *(t+m1._sCol*i+j)=sum;
   }
}
CMatrix<T> m(t,_sLn,m1._sCol);
delete [] t;
return m;
}else{
assert(0);//未知运算
return *this;
}
}

template<typename T>
CMatrix<T> operator*(double alpha,CMatrix<T> & m1)
{
CMatrix<T> m=m1;
for(long i=0;i<m._sLn;i++){
for(long j=0;j<m._sCol;j++){
m[i][j]=alpha*m1[i][j];
}
}
return m;
}

template<typename T>
CMatrix<T> CMatrix<T>::operator*(double alpha)
{
return alpha*(*this);
}

template<typename T>
CMatrix<T> CMatrix<T>::operator+=(CMatrix<T> & m)
{
return *this+m;
}

template<typename T>
CMatrix<T> CMatrix<T>::operator-=(CMatrix<T> & m)
{
return *this-m;
}

template<typename T>
CMatrix<T> CMatrix<T>::operator *=(double alpha)
{
return *this*alpha;
}

template<typename T>
CMatrix<T> CMatrix<T>::operator *=(CMatrix<T> & m1)
{
return *this*m1;
}

template<typename T>
const T* CMatrix<T>::c_ptr () const
{
return _pData;
}

template<typename T>
CMatrix<T> CMatrix<T>::operator /(CMatrix<T> &m1)
{
assert(m1._sCol==1 && m1._sLn==1);
assert(m1[0][0]!=0);
return *this/m1[0][0];
}

template<typename T>
CMatrix<T> CMatrix<T>::operator /(double sub)
{
assert(sub!=0);
CMatrix<T> m=*this;
for(long i=0;i<_sLn;i++){
for(long j=0;j<_sCol;j++){
m[i][j]=*((T*)_pData+_sCol*i+j)/sub;
}
}
return m;
}

template<typename T>
CMatrix<T> & CMatrix<T>::operator =(CMatrix<T> & m)
{
if(&m==this) return *this;

_sLn=m._sLn;
_sCol=m._sCol;
if(_pData)
{
delete [] _pData;
_pData = NULL;
}
_pData=new T[_sLn*_sCol];
memcpy(_pData,m._pData,_sLn*_sCol*sizeof(T));

return *this;
}

template<typename T>
bool operator == (CMatrix<T>& m1,CMatrix<T>& m2)
{
if (&m1 == &m2)
{
return true;
}

if (m1.getWidth()!=m2.getWidth() || m1.getHeight()!=m2.getHeight())
{
return false;
}

T *p1,*p2;
p1 = m1[0];
p2 = m2[0];
long sum = m1.getHeight()*m1.getWidth();
long i;
if(typeid(T) == typeid(float))
  for (i=0;i<sum;i++)
  {
   if (fabs(*p1++ - *p2++)<CMatrix<T>::m_fPrecision)
   {
    return false;
   }
  }
if(typeid(T) == typeid(double))
  for (i=0;i<sum;i++)
  {
   if (fabs(*p1++ - *p2++)<CMatrix<T>::m_dPrecision)
   {
    return false;
   }
  }
else
  for (i=0;i<sum;i++)
  {
   if (*p1++ != *p2++)
   {
    return false;
   }
  }

return true;
}

template<typename T>
T operator+(double dbl,CMatrix<T> & m)
{
assert(m.getHeight()==1 && m.getWidth()==1);
return dbl+m[0][0];
}

template<typename T>
T operator+(CMatrix<T> & m,double dbl)
{
return dbl+m;
}

template<typename T>
T operator-(double dbl,CMatrix<T> & m)
{
assert(m.getHeight()==1 && m.getWidth()==1);
return dbl-m[0][0];
}

template<typename T>
T operator-(CMatrix<T> & m,double dbl)
{
return -(dbl-m);
}

template<typename T>
CMatrix<T>::CLine CMatrix<T>::operator [](long heightPos)
{
assert(isValid());
assert(heightPos>=0 && heightPos<=_sLn);//报错

CLine rLine(_pData+heightPos*_sCol,this);
return rLine;//取回的是行头指针
}

//
//输出

template<typename T>
std::ostream & operator<<(std::ostream & os,jks::CMatrix<T> & m)
{
os<<"Sum Ln:"<<m._sLn<<" "<<"Sum Col:"<<m._sCol<<std::endl;
long i,j;

if(typeid(T)==typeid(unsigned char))
  for (i=0;i<m._sLn;i++)
  {
   for (j=0;j<m._sCol;j++)
   {
    os<<(int)m._pData[i*m._sCol+j]<<"/t";
   }
   os<<std::endl;
  }
else
  for (i=0;i<m._sLn;i++)
  {
   for (j=0;j<m._sCol;j++)
   {
    os<<m._pData[i*m._sCol+j]<<"/t";
   }

os<<std::endl;
}

return os;
}

//
template<typename T>
int CMatrix<T>::isVector()
{
//return !(nWidth==1 && nHeight==1);
if (_sCol==1)
  if (_sLn==1)
   return 0;
  else
   return 1;
else
  return -1;
}

//
} //
#endif // !defined(__JKS_MATRIX_HPP_)