重构-C++实现矩阵

#include <iostream>
#include <cmath> 
using namespace std;
double cofactor(double* detPtr,int rank,int t);     //代数余子式 
double valDet( double *detPtr, int rank);           //行列式 

template <class T>
void exchange(T& t1,T& t2){T temp;temp=t1;t1=t2;t2=temp;} //交换
 
class SquareMatrix;
class Matrix{
    public:
        friend class SquareMatrix;         //配合转换函数食用
        Matrix(){m=n=mn=0;}                //默认构造函数 
        Matrix(int mt,int nt);             //构造矩阵 
        Matrix(const Matrix& mtrx);        //复制构造函数 
        Matrix(int mt,int nt,double* a);   //数组初始化矩阵 
        
        Matrix transposeMtrx();            //转置矩阵 
                                                           //初等变换
        void exchangeRow(int r1,int r2,int c=0);           //交换行 
        void multiRow(int r,int k,int c=0);                //数乘行
        void addMultiRow(int r1,int r2,int k=1,int c=0);   //r1+=k*r2
        void exchangeColumn(int c1,int c2,int r=0);           //交换列 
        void multiColumn(int c,int k,int r=0);                //数乘列 
        void addMultiColumn(int c1,int c2,int k=1,int r=0);   //c1+=k*c2

        Matrix& operator =(const Matrix& mtrx);  //赋值构造函数 
        friend istream& operator>>(istream& input,Matrix& mtrx); 
        friend ostream& operator<<(ostream& output,Matrix& mtrx);  //输出矩阵 
        friend Matrix operator*(Matrix& m1,Matrix& m2);    //矩阵乘法 
    protected:
        int m;
        int n;
        int mn;
        double* matrixPtr;
};

class SquareMatrix:public Matrix{
    public:
        SquareMatrix():Matrix(){}                          //默认构造函数 
        SquareMatrix(int mt):Matrix(mt,mt){};              //构造函数 
        SquareMatrix(int mt,double* a):Matrix(mt,mt,a){};  //数组初始化方阵 
        SquareMatrix(const Matrix& mtrx);                  //矩阵到方阵转换 
        
        SquareMatrix transposeSqrMtrx();        //转置方阵 
        SquareMatrix adjugateSqrMatrix();       //伴随矩阵 
        SquareMatrix inverseSqrMatrix();        //逆矩阵 

        friend istream& operator>>(istream& input,SquareMatrix& mtrx); 
                                                           //输入方阵 
        friend SquareMatrix operator *(SquareMatrix& sm1,SquareMatrix& sm2);
                                                           //方阵乘法 
        double getDet();                                   //行列式的值 
    private:
};

Matrix::Matrix(int mt,int nt){               //初始化m*n矩阵 
    m=mt;n=nt;mn=m*n;
    matrixPtr=new double[mn];
}

Matrix::Matrix(const Matrix& mtrx){          //复制构造函数 
    m=mtrx.m;n=mtrx.n;mn=mtrx.mn;
    matrixPtr=new double[mn];
    for(int i=0;i<mn;i++) matrixPtr[i]=mtrx.matrixPtr[i];
}

Matrix::Matrix(int mt,int nt,double* a){     //数组初始化m*n矩阵 
    m=mt;n=nt;mn=m*n;
    matrixPtr=new double[mn];
    for(int i=0;i<mn;i++)
        matrixPtr[i]=a[i];
}

istream& operator>>(istream& input,Matrix& mtrx){    //重载>> 
    if(!mtrx.m){
        cout<<"enter the m,n of matrix:";
        input>>mtrx.m>>mtrx.n;
        mtrx.mn=mtrx.m*mtrx.n;
        mtrx.matrixPtr=new double[mtrx.mn];
        cout<<"enter the matrix:"<<endl;
    }
    else cout<<"enter a "<<mtrx.m<<‘*‘<<mtrx.n<<" matrix:"<<endl;
    for(int i=0;i<mtrx.mn;i++) input>>mtrx.matrixPtr[i];
    return input;
}

Matrix Matrix::transposeMtrx(){                      //转置矩阵 
    Matrix mtrx(n,m);
    for(int i=0;i<n;i++)
        for(int j=0;j<m;j++)
            mtrx.matrixPtr[m*i+j]=matrixPtr[n*j+i];
    return mtrx;
}

void Matrix::exchangeRow(int r1,int r2,int c){         //交换行,默认c=0 
    for(int i=c;i<n;i++)
        exchange(matrixPtr[n*r1+i],matrixPtr[n*r2+i]);
}

void Matrix::multiRow(int r,int k,int c){              //数乘行,默认c=0 
    for(int i=c;i<n;i++)
            matrixPtr[n*r+i]*=k;
}

void Matrix::addMultiRow(int r1,int r2,int k,int c){   //r1+=k*r2,默认k=1,c=0 
    for(int i=c;i<n;i++)
        matrixPtr[n*r1+i]+=matrixPtr[n*r2+i]*k;
}

void Matrix::exchangeColumn(int c1,int c2,int r){        //交换列,默认r=0 
    for(int i=r;i<m;i++)
        exchange(matrixPtr[n*i+c1],matrixPtr[n*i+c2]);
}

void Matrix::multiColumn(int c,int k,int r){             //数乘列,默认k=1,r=0
    for(int i=r;i<m;i++)
        matrixPtr[n*i+c]*=k;
}

void Matrix::addMultiColumn(int c1,int c2,int k,int r){  //c1+=k*c2,默认r=0 
    for(int i=r;i<m;i++)
        matrixPtr[n*i+c1]+=matrixPtr[n*i+c2]*k;
}

Matrix& Matrix::operator=(const Matrix& mtrx){       //重载= 
    m=mtrx.m;n=mtrx.n;mn=m*n;
    matrixPtr=new double[mn];
    for(int i=0;i<mn;i++) matrixPtr[i]=mtrx.matrixPtr[i];
    return *this;
}

ostream& operator<<(ostream& output,Matrix& mtrx){   //重载<< 
    output<<endl;
    for(int i=0;i<mtrx.m;i++){
        for(int j=0;j<mtrx.n;j++)
            output<<mtrx.matrixPtr[mtrx.n*i+j]<<‘ ‘;
        output<<endl;
    }
    output<<endl;
    return output;
}

Matrix operator *(Matrix& m1,Matrix& m2){                //重载* 
    Matrix m3(m1.m,m2.n);
    for(int i=0;i<m3.m;i++)
        for(int j=0;j<m3.n;j++){
            double val=0;
            for(int k=0;k<m2.m;k++)
                val+=m1.matrixPtr[m1.n*i+k]*m2.matrixPtr[m2.n*k+j];
            m3.matrixPtr[m3.n*i+j]=val;
        }
    return m3;
}

//我是萌萌哒分割线-------------------------------------------------------

SquareMatrix::SquareMatrix(const Matrix& mtrx){                  //构造函数 
    m=n=mtrx.m;mn=m*n;matrixPtr=new double[mn];
    for(int i=0;i<mn;i++) matrixPtr[i]=mtrx.matrixPtr[i];
} 

istream& operator>>(istream& input,SquareMatrix& mtrx){    //重载>> 
    if(!mtrx.m){
        cout<<"enter the m of squareMatrix:";
        input>>mtrx.m;
        mtrx.n=mtrx.m;mtrx.mn=mtrx.m*mtrx.n;
        mtrx.matrixPtr=new double[mtrx.mn];
        cout<<"enter the squareMatrix:"<<endl;
    }
    else cout<<"enter a "<<mtrx.m<<" order squareMatrix:"<<endl;
    for(int i=0;i<mtrx.mn;i++) input>>mtrx.matrixPtr[i];
    return input;
}

SquareMatrix SquareMatrix::transposeSqrMtrx(){             //转置方阵 
    return SquareMatrix((*this).transposeMtrx());
} 

SquareMatrix SquareMatrix::adjugateSqrMatrix(){            //伴随矩阵 
    SquareMatrix aSM(m);
    for(int i=0;i<mn;i++)
        aSM.matrixPtr[i]=cofactor(matrixPtr,m,i);
    aSM=aSM.transposeSqrMtrx();
    return aSM;
}

SquareMatrix SquareMatrix::inverseSqrMatrix(){             //逆矩阵 
    double det=getDet();
    if(det==0){
        cerr<<"this is a singular matrix!"<<endl;    //判断奇异矩阵
        return 0; 
    }
    SquareMatrix aSM(m),iSM(m);
    aSM=adjugateSqrMatrix();
    for(int i=0;i<mn;i++)
        iSM.matrixPtr[i]=aSM.matrixPtr[i]/det;
    return iSM;
}

SquareMatrix operator *(SquareMatrix& sm1,SquareMatrix& sm2){     //重载*  
    SquareMatrix sm3(sm1.m);
    for(int i=0;i<sm3.m;i++)
        for(int j=0;j<sm3.n;j++){
            double val=0;
            for(int k=0;k<sm2.m;k++)
                val+=sm1.matrixPtr[sm1.n*i+k]*sm2.matrixPtr[sm2.n*k+j];
            sm3.matrixPtr[sm3.n*i+j]=val;
        }
    return sm3;
}

double SquareMatrix::getDet(){                   //行列式 
    return valDet(matrixPtr,m);
}

//又是一条萌萌哒分割线------------------------------------------

double valDet( double *detPtr, int rank)
{
    double val=0;
    if(rank==1) return detPtr[0];
    for(int i=0;i<rank;i++)                   //计算余子式保存在nextDetPtr[]中 
    {
        double *nextDetPtr=new double[(rank-1)*(rank-1)];
        for(int j=0;j<rank-1;j++)
            for(int k=0;k<i;k++)
                nextDetPtr[j*(rank-1)+k]=detPtr[(j+1)*rank+k];
        for(int j=0;j<rank-1;j++)
            for(int k=i;k<rank-1;k++)
                nextDetPtr[j*(rank-1)+k]=detPtr[(j+1)*rank+k+1];
        val+=detPtr[i]*valDet(nextDetPtr,rank-1)*pow(-1.0,i);
    }
    return val;
}

double cofactor(double* detPtr,int rank,int t){                     //计算代数余子式 
    double *nextDetPtr=new double[(rank-1)*(rank-1)];
    for(int i=0,j=0;i<rank*rank;i++)
        if(i>=(t/rank)*rank&&i<(t/rank)*rank+rank||!((t-i)%rank));   //如果i和t同行或同列 
        else{
            nextDetPtr[j]=detPtr[i];
            j++;
        }
    return valDet(nextDetPtr,rank-1)*pow(-1.0,t/rank+t%rank);
} 

int main(){
    cout<<endl<<"测试驱动程序-------------------"<<endl;
    /*
    cout<<endl<<"输入任意矩阵-------------------"<<endl; 
    Matrix m1;cin>>m1;cout<<m1;
    
    cout<<endl<<"输入任意方阵-------------------"<<endl;
    SquareMatrix sm1;cin>>sm1;cout<<sm1;
    
    cout<<endl<<"输入3*2矩阵--------------------"<<endl;
    Matrix m2(3,2);cin>>m2;cout<<m2;
    
    cout<<endl<<"输入2阶方阵--------------------"<<endl;
    SquareMatrix sm2(2);cin>>sm2;cout<<sm2;
    */
    cout<<endl<<"数组初始化矩阵-----------------"<<endl;
    double a1[6]={1,2,3,7,8,9};
    Matrix m3(2,3,a1);cout<<m3;
    
    cout<<endl<<"数组初始化方阵-----------------"<<endl;
    double a2[4]={3,4,5,6};
    SquareMatrix sm3(2,a2);cout<<sm3; 
    
    cout<<endl<<"复制构造方阵/矩阵--------------"<<endl;
    Matrix m4;m4=m3;Matrix m5(m3);
    cout<<m4<<m5;
    SquareMatrix sm4;sm4=sm3;SquareMatrix sm5(sm3);
    cout<<sm4<<sm5; 
    
    cout<<endl<<"矩阵/方阵乘法------------------"<<endl;
    double a3[6]={1,0,3,2,1,0},a4[9]={4,1,0,-1,1,3,2,0,1};
    Matrix m6(2,3,a3),m7(3,3,a4);
    Matrix m8=m6*m7;cout<<m8;
    
    double a5[4]={1,2,2,3},a6[4]={2,3,4,1};
    SquareMatrix sm6(2,a5),sm7(2,a6);
    SquareMatrix sm8(sm6*sm7);cout<<sm8;
    
    cout<<endl<<"矩阵转换为方阵-----------------"<<endl;
    SquareMatrix sm9(m7);cout<<m7<<sm9;
    
    cout<<endl<<"转置矩阵/方阵------------------"<<endl;
    Matrix m9(m6.transposeMtrx());
    cout<<m6<<m9;
    SquareMatrix sm10=sm9.transposeSqrMtrx();
    cout<<sm9<<sm10; 
    
    cout<<endl<<"初等变换-----------------------"<<endl;
    cout<<m3<<m4;
    m4.exchangeRow(0,1,2);cout<<m3<<m4;
    m4.exchangeRow(0,1);cout<<m4;
    m4.exchangeColumn(0,2);cout<<m4;
    m4.multiRow(1,2);cout<<m4;
    m4.multiColumn(1,2,1);cout<<m4;
    m4.addMultiRow(0,1);cout<<m4;
    m4.addMultiColumn(0,2,2,1);cout<<m4;
    cout<<sm3<<sm4;
    sm4.exchangeRow(0,1);cout<<sm3<<sm4;
    
    cout<<endl<<"方阵的行列式值-----------------"<<endl;
    cout<<sm3<<sm3.getDet()<<endl; 
    
    cout<<endl<<"逆矩阵-------------------------"<<endl;
    SquareMatrix sm11=sm3.inverseSqrMatrix();cout<<sm11;
    SquareMatrix sm12=sm3*sm11;cout<<sm12;
    return 0;
}