矩阵类的代码（C++）

The Codes of Matrix Class

Matrix.h：
#ifndef MATRIX_H
#define MATRIX_H
#include<iostream>
#include<iomanip>
#include<cassert>
#include<cmath>
#include"MatrixTypedef.h"// declare typedef‘s header file 
class Matrix{
public:
Matrix(const un_int &r = 0, const un_int &c = 0, const double &number = 0);// The constructor with the parameters
Matrix(const Matrix &mat);// The copy constructor 
~Matrix();// The destructor 
un_int getRows(void) const { return m_rows; }// Accessor, get the value of rows 
un_int getCols(void) const { return m_cols; }// Accessor，get the value of cols

void resize(const un_int &r, const un_int &c, const double &number);// Reseting the values of rows, cols and matrix members 

bool isEmpty(void) const;// The judgment if matrix is empty 
vec& operator [](const un_int &i) ;// Overloading the subscript operator[] 

const vec& operator [](const un_int &i) const;// Overloading the subscript operator[]
friend istream& operator >>(istream &sin, Matrix &mat);// Overloading  the operator >>
friend ostream& operator <<(ostream &sout, const Matrix &mat);// Overloading the operator <<       
friend Matrix operator +(const Matrix &l, const Matrix &r);// Overloading matrix addtion        
friend Matrix operator -(const Matrix &l, const Matrix &r);// Overloading matrix subtraction         
friend Matrix operator *(const double &x, const Matrix &mat);// Overloading matrix multiplication
friend Matrix operator *(const Matrix &mat, const double &x);// Overloading matrix multiplication 
friend Matrix operator *(const Matrix &l, const Matrix &r);// Overloading matrix multiplication 
Matrix operator !(void);// Solving the inverse of a matrix 
Matrix operator ~(void);// Solving the transpose of the matrix 
double Det(void);// Solving the Determinant

private:
un_int m_rows, m_cols;// The values of rows and cols 
Mat data;// The values of Matrix 
void Resize(Mat &mat, const un_int &r, const un_int &c);// Resetting vector<vector<double>>‘s size

double GetDet(const Mat &mat, const un_int &n);// Solving the Determinan 
double GetCofactor(const un_int m, const un_int n);// Solving algebraic cofactor
};
#endif

Matrix.cpp：
#include"Matrix.h"

// The constructor with the parameters

Matrix::Matrix(const un_int &r, const un_int &c, const double &number){
// If cols and rows are greater than or equal to 0
assert(r >= 0);
assert(c >= 0);

m_rows = r; m_cols = c;

// Resetting and initialising the matrix 

Resize(data, m_rows, m_cols);
for(un_int i = 0;i < m_rows;++i){
    for(un_int j = 0;j < m_cols;++j){
        data[i][j] = number;

    }

}

}

// The destructor 
Matrix::~Matrix(void){
// Using swap function forcing to release the memory space 
for(un_int i = 0;i < m_rows;++i){
    vec().swap(data[i]);

}
Mat().swap(data);

}

// The copy constructor 
Matrix::Matrix(const Matrix &mat){
if(!mat.isEmpty()){
m_rows = mat.getRows();
m_cols = mat.getCols();

// Resetting matrix‘s size and values 
Resize(data, m_rows, m_cols);
for(un_int i = 0;i < m_rows;++i){
    for(un_int j = 0;j < m_cols;++j){
        data[i][j] = mat[i][j];

    }

}

}

}

// The definition of resize function
void Matrix::resize(const un_int &r, const un_int &c, const double &number){
// If cols and rows are greater than or equal to 0 
assert(r >= 0);
assert(c >= 0);

m_rows = r;
m_cols = c;
// Resetting matrix‘s size and values 
Resize(data, m_rows, m_cols);
for(un_int i = 0;i < m_rows;++i){
    for(un_int j = 0;j < m_cols;++j){
        data[i][j] = number;

    }

}

}
// If matrix is empty

bool Matrix::isEmpty(void) const{
bool flag = true; // If all of the member of matrix is empty 
for(un_int i = 0;i < m_rows;++i){
    if(!data[i].empty()){

        flag = false; break;

    }

}
return flag;

}

// Overloading the subscript operator[] 
vec& Matrix::operator [](const un_int &i) {
// If memory accessing is out of bounds

assert(i >= 0);
assert(i < m_rows);
return data[i];

}

// Overloading the subscript operator[]
const vec& Matrix::operator [](const un_int &i) const {
// If memory accessing is out of bounds
assert(i >= 0);
assert(i < m_rows);
return data[i];

}

// Overloading  the operator >> 
istream& operator >>(istream &sin, Matrix &mat){
sin >> mat.m_rows >> mat.m_cols;
// If cols and rows are greater than 0
assert(mat.m_rows > 0);
assert(mat.m_cols > 0);
// Resetting matrix‘s size and values
mat.resize(mat.m_rows, mat.m_cols, 0);
for (un_int i = 0;i < mat.m_rows;++i) {
    for (un_int j = 0;j < mat.m_cols;++j) {
        sin >> mat[i][j];

    }

}
return sin;

}

// Overloading the operator << 
ostream& operator <<(ostream &sout, const Matrix &mat){
// If cols and rows are greater than 0
assert(mat.m_rows > 0);
assert(mat.m_cols > 0);
// Outputting matrix 
for (un_int i = 0;i < mat.m_rows;++i){
    for(un_int j = 0;j < mat.m_cols;++j){
        sout.setf(ios::fixed);
        sout.precision(3);
        sout << right << setw(6) << mat[i][j] << (j == (mat.m_cols - 1)?‘\n‘ : ‘ ‘);

    }

}
        cout << endl;
return sout;

}

// Overloading matrix multiplication 
Matrix operator *(const double &x, const Matrix &mat){
// If cols and rows are greater than 0
assert(mat.m_rows > 0);
assert(mat.m_cols > 0);
Matrix temp(mat.m_rows, mat.m_cols, 0);
for(un_int i = 0;i < mat.m_rows;++i){
    for(un_int j = 0;j < mat.m_cols;++j){
        temp[i][j] = x * mat[i][j];

    }

}
return temp;

}

// Overloading matrix multiplication 
Matrix operator *(const Matrix &mat, const double &x){
// If cols and rows are greater than 0
assert(mat.m_rows > 0);
assert(mat.m_cols > 0);
Matrix temp(mat.m_rows, mat.m_cols, 0);
for(un_int i = 0;i < mat.m_rows;++i){
    for(un_int j = 0;j < mat.m_cols;++j){
        temp[i][j] = x * mat[i][j];

    }

}
return temp;

}

// Overloading matrix addtion
Matrix operator +(const Matrix &l, const Matrix &r){
// If the rows and cols between the two matrixs are equal
assert(l.m_rows == r.m_rows);
assert(l.m_cols == r.m_cols);
Matrix temp(l.m_rows, r.m_cols, 0);
for(un_int i = 0;i < l.m_rows;++i){
    for(un_int j = 0;j < l.m_cols;++j){
        temp[i][j] = l[i][j] + r[i][j];

    }

}
return temp;

}

// Overloading matrix subtraction 
Matrix operator -(const Matrix &l, const Matrix &r){
// If the rows and cols between the two matrixs are equal
assert(l.m_rows == r.m_rows);
assert(l.m_cols == r.m_cols);
Matrix temp(l.m_rows, r.m_cols, 0);
for(un_int i = 0;i < l.m_rows;++i){
    for(un_int j = 0;j < l.m_cols;++j){
       temp[i][j] = l[i][j] - r[i][j];

    }

}
return temp;

}

// Overloading matrix multiplication 
Matrix operator *(const Matrix &l, const Matrix &r){
// If  the left operand‘s cols is equal to the right operand‘s rows
assert(l.m_cols == r.m_rows);
// Using formula solving matrix multiplication 
Matrix temp(l.m_rows, r.m_cols, 0);
for(un_int i = 0;i < l.m_rows;++i){
    for(un_int j = 0;j < r.m_cols;++j){
        for(un_int k = 0;k < l.m_cols;++k){
            temp[i][j] += (l[i][k] * r[k][j]);

        }

    }

}
return temp;

}

// Solving the inverse of a matrix 
Matrix Matrix::operator !(void){
const double det = Det();// Solving the Determinan 
// If determinan is equal to 0 and matrix‘s rows is equal to cols 
assert(fabs(det) > EPS);
assert(m_rows == m_cols);
// Solving the inverse of a matrix 
Mat temp = data; for(un_int i = 0,k = 0;i < m_rows;++i, ++k){
for(un_int j = 0, l = 0;j < m_cols;++j, ++l){
    double n = GetCofactor(k, l) / det;

    if(fabs(n) < EPS) n = 0.0; // If double value is equal to 0
        data[j][i] = n;

    }

}
return *this;

}

// Solving the transpose of the matrix 
Matrix Matrix::operator ~(void){
// If cols and rows are greater than or equal to 0
assert(m_rows > 0);
assert(m_cols > 0);

// If rows is equal to cols

if(m_rows == m_cols){
for(un_int i = 1;i < m_rows;++i){
    for(un_int j = 0;j <= i;++j){
        swap(data[i][j],data[j][i]); } }
        return *this;

}

// If rows is diffierent from cols 
else { Matrix temp(m_cols, m_rows, 0);
    for(un_int i = 0;i < m_cols;++i){
        for(un_int j = 0;j < m_rows;++j){
            temp[i][j] = data[j][i];

        }

   }
            return temp;

}

}

// Solving the Determinant 
double Matrix::Det(void){
// If rows is equal to cols
assert(m_rows == m_cols);
return GetDet(data, m_rows);

}
// The definition of Resize function 
void Matrix::Resize(Mat &mat, const un_int &r, const un_int &c){ 

// Resetting cols
mat.resize(r);
// Resetting rows
for(un_int i = 0;i < r;++i){ mat[i].resize(c); }}
// The definition of GetDet function

GetDet double Matrix::GetDet(const Mat &mat,const un_int &n){ double ans = 0;
// Solving the determinant
if(n == 1) {return mat[0][0]; }
else { Mat temp; temp.resize(n);
for(un_int i = 0;i < n;++i){ temp[i].resize(n); }
for(un_int i = 0;i < n;++i){ // Getting algebraic cofactor of first row,j+1 th col 
    un_int p = 0; for(un_int j = 0;j < n;++j){
    if(j != 0){ un_int q = 0;
    for(un_int k = 0;k < n;++k){
        if(k != i){ temp[p][q] = mat[j][k]; ++q;

        }

    }
    ++p;

    }

}
ans += pow(-1, i)*mat[0][i]*GetDet(temp, n - 1); }
return ans;

}

}

// The definition of GetCofactor function
double Matrix::GetCofactor(const un_int m, const un_int n){
Matrix temp(m_rows - 1, m_cols - 1, 0);
// Getting algebraic cofactor of m th row,n th col 
for(un_int i = 0, k = 0, l = 0;i < m_rows;++i){
     for(un_int j = 0;j < m_cols;++j){

         if(i != m && j != n){
             temp[k][l] = data[i][j]; ++l;
             if(l == m_cols - 1){ l = 0; ++k;

             }

         }

     }

}
const int sign = (((m + n + 2) & 1) == 0?1 : -1);
return sign * temp.Det();// Getting cofactor‘s determinant

}

MatrixTypedef.h:
#ifndef MATRIXTYPEDEF_H
#define MATRIXTYPEDEF_H
#include<vector>
using namespace std;
typedef vector<double> vec;
typedef vector<vec> Mat;
typedef unsigned int un_int;
const double EPS = 1e-6;
#endif

原文链接：http://user.qzone.qq.com/1043480007/main