C++实现矩阵Matrix类 实现基本运算_c++ matrix
本系列文章致力于实现“手搓有限元，干翻Ansys的目标”，基本框架为前端显示使用QT实现交互，后端计算采用Visual Studio C++。
目录
Matrix类
1、public function
1.1、构造函数与析构函数
1.3、设置矩阵
1.4、矩阵转置、单位化
1.5、矩阵的删除与替换
1.6、矩阵初等变换
1.7、矩阵加法
1.8、矩阵乘法
1.9、行列式相关操作
1.10、矩阵求逆
2、private variable
3、全部源码
Matrix类
矩阵基本类，用于有限元矩阵计算。
1、public function
公共成员函数，调用可实现基本运算
1.1、构造函数与析构函数
构造函数用来初始化矩阵，析构函数用来释放内存。
Matrix.h声明文件：
/*函数名称:无参构造函数*/Matrix();/*函数名称:矩阵有参构造函数，初始化为row行、col列的0矩阵row:矩阵行数col:矩阵列数*/Matrix(int row, int col);/*函数名称:矩阵有参构造函数，初始化为row行、col列、数值为mat的矩阵row:矩阵行数col:矩阵列数*mat:矩阵数值一维数组*/Matrix(int row, int col, double* mat);/*函数名称:深拷贝构造函数mat:需要复制的矩阵*/Matrix(const Matrix& mat);/*函数名称:析构函数*/~Matrix();Matrix.cpp函数实现文件：
Matrix::Matrix(){}//初始化矩阵 默认值为0Matrix::Matrix(int row, int col){this->m_Row = row;this->m_Col = col;//开辟内存this->m_Matrix = new double* [row];for (int i = 0; i m_Matrix[i] = new double[col] {0.0};}}//初始化矩阵 设定数值Matrix::Matrix(int row, int col, double *mat){this->m_Row = row;this->m_Col = col;//开辟内存this->m_Matrix = new double* [row];for (int i = 0; i m_Matrix[i] = new double[col] {0.0};}//矩阵赋值for(int i = 0; i<row; i++){for (int j = 0; j 1.2、获取矩阵数值
可以获取矩阵指定位置数值、打印矩阵。
Matrix.h声明文件：
//*******************获取矩阵*****************///*函数名称:获取矩阵的第row行、第col列元素数值row:矩阵行数col:矩阵列数*/double GetMatrixEle(int row, int col);/*函数名称:打印矩阵*/void PrintMat();Matrix.cpp函数实现文件：
//获取矩阵某个元素 某行某列double Matrix::GetMatrixEle(int row, int col){if (row >= this->m_Row){std::cout << \"Error: Input row >= m_Row\" <= this->m_Col){std::cout << \"Error: Input col >= m_Col\" <m_Matrix[row][col];}}//矩阵输出void Matrix::PrintMat(){for (int i = 0; i m_Row; i++){for (int j = 0; j m_Col; j++){std::cout.setf(std::ios::scientific);//科学计数法表示std::cout <m_Matrix[i][j] << \"\\t\";}std::cout << std::endl;}std::cout << std::endl;}测试验证：
测试代码：
#include \"Matrix.h\"int main(){//定义矩阵数值double tempValue[9] = {1.0, 2.0, 3.0,4.0, 5.0, 6.0,7.0, 8.0, 0.0};//创建矩阵Matrix* tempMatrix = new Matrix(3, 3, tempValue);//打印矩阵tempMatrix->PrintMat();system(\"pause\");return 0;}应用输出：
1.000000e+00 2.000000e+00 3.000000e+004.000000e+00 5.000000e+00 6.000000e+007.000000e+00 8.000000e+00 0.000000e+00请按任意键继续. . .1.3、设置矩阵
可进行设置矩阵指定位置数值，以及深拷贝矩阵。
Matrix.h声明文件：
/*函数名称:设置矩阵第row行、第col列数值row:矩阵行数col:矩阵列数value:设置的矩阵数值*/void SetMatrixEle(int row, int col, double value);/*函数名称:深拷贝矩阵mat:需要复制的矩阵*/Matrix CopyMat(const Matrix mat);Matrix.cpp函数实现文件：
//*******************设置矩阵*****************//void Matrix::SetMatrixEle(int row, int col, double value){if (row >= this->m_Row){std::cout << \"Error: Input row >= m_Row\" <= this->m_Col){std::cout << \"Error: Input col >= m_Col\" <m_Matrix[row][col] = value;return;}}//深拷贝矩阵Matrix Matrix::CopyMat(const Matrix mat){//行列传递this->m_Row = mat.m_Row;this->m_Col = mat.m_Col;//矩阵深拷贝this->m_Matrix = new double* [this->m_Row];for (int i = 0; i m_Row; i++){this->m_Matrix[i] = new double[this->m_Col];memcpy(this->m_Matrix[i], mat.m_Matrix[i], sizeof(double) * this->m_Col);}return *this;}测试验证：
测试代码：
int main(){//定义矩阵数值double tempValue[9] = {1.0, 2.0, 3.0,4.0, 5.0, 6.0,7.0, 8.0, 0.0};//创建矩阵Matrix* tempMatrix = new Matrix(3, 3, tempValue);//打印矩阵std::cout << \"数值更改前:\" <PrintMat();//更改特定值tempMatrix->SetMatrixEle(1, 1, 10.0);//打印矩阵std::cout << \"数值更改后:\" <PrintMat();system(\"pause\");return 0;}应用输出：
数值更改前:1.000000e+00 2.000000e+00 3.000000e+004.000000e+00 5.000000e+00 6.000000e+007.000000e+00 8.000000e+00 0.000000e+00数值更改后:1.000000e+00 2.000000e+00 3.000000e+004.000000e+00 1.000000e+01 6.000000e+007.000000e+00 8.000000e+00 0.000000e+00请按任意键继续. . .1.4、矩阵转置、单位化
可进行矩阵转置，单位化，注意返回值类型为自身的引用，可实现链式编程。
Matrix.h声明文件：
/*函数名称:矩阵转置，返回的是自身引用，可链式调用*/Matrix& Transpose();/*函数名称:等维度的单位矩阵，前提是方阵*/Matrix& Uint();Matrix.cpp函数实现文件：
//矩阵转置Matrix& Matrix::Transpose(){Matrix* resMat = new Matrix(this->m_Col, this->m_Row);for (int i = 0; i m_Row; i++){for (int j = 0; j m_Col; j++){resMat->m_Matrix[j][i] = this->m_Matrix[i][j];}}return *resMat;}//求等长度单位矩阵Matrix& Matrix::Uint(){//矩阵是否为方阵if (this->m_Col != this->m_Row){std::cout << \"Error: Row != Col\" <m_Row, this->m_Row);return *resMat;}else{//单位矩阵初始化Matrix* resMat = new Matrix(this->m_Row, this->m_Col);//单位矩阵生成for (int i = 0; i m_Row; i++){resMat->m_Matrix[i][i] = 1.0;}return *resMat;}}测试验证：
测试代码：
int main(){//定义矩阵数值double tempValue[9] = {1.0, 2.0, 3.0,4.0, 5.0, 6.0,7.0, 8.0, 0.0};//创建矩阵Matrix* tempMatrix = new Matrix(3, 3, tempValue);//打印矩阵std::cout << \"数值转置前:\" <PrintMat();//打印矩阵(注意可链式编程)std::cout << \"数值转置后:\" <Transpose().PrintMat();system(\"pause\");return 0;}应用输出：
数值转置前:1.000000e+00 2.000000e+00 3.000000e+004.000000e+00 5.000000e+00 6.000000e+007.000000e+00 8.000000e+00 0.000000e+00数值转置后:1.000000e+00 4.000000e+00 7.000000e+002.000000e+00 5.000000e+00 8.000000e+003.000000e+00 6.000000e+00 0.000000e+00请按任意键继续. . .1.5、矩阵的删除与替换
可进行矩阵指定行、列的删除与替换，注意返回值类型为自身的引用，可实现链式编程。
Matrix.h声明文件：
/*函数名称:剔除矩阵中以index为行标和列标的行和列，num代表index的大小*index:矩阵中的行号与列号一维数组num:index动态数组长度*/Matrix& DeleteMat(int *index, int num);/*函数名称:剔除矩阵中以index为行标和列标的行和列，num代表index的大小*index:矩阵中的行号与列号一维动态数组num:index动态数组长度*/Matrix& DeleteMat(std::vector index, int num);/*函数名称:剔除矩阵中以index为行标的行，num代表index的大小*index:矩阵中的行号一维数组num:index动态数组长度*/Matrix& DeleteRow(int* index, int num);/*函数名称:剔除矩阵中以index为行标的行，num代表index的大小*index:矩阵中的行号一维动态数组num:index动态数组长度*/Matrix& DeleteRow(std::vector index, int num);/*函数名称:剔除矩阵中以index为列标的列，num代表index的大小*index:矩阵中的列号一维数组num:index动态数组长度*/Matrix& DeleteCol(int* index, int num);/*函数名称:剔除矩阵中以index为列标的列，num代表index的大小*index:矩阵中的列号一维动态数组num:index动态数组长度*/Matrix& DeleteCol(std::vector index, int num);//******************矩阵的替换****************///*函数名称:替换矩阵中行标和列标为 index中的行与列，num代表index的大小, mat是需要替换的矩阵*index:矩阵中的行标和列标的一维数组num:index动态数组长度mat:需要替换的矩阵*/Matrix& ReplaceMat(int* index, int num, Matrix& mat);/*函数名称:替换矩阵中行标和列标为 index中的行与列，num代表index的大小, mat是需要替换的矩阵*index:矩阵中的行标和列标的一维动态数组num:index动态数组长度mat:需要替换的矩阵*/Matrix& ReplaceMat(std::vector index, int num, Matrix& mat);/*函数名称:替换矩阵中行标为 index中的行，num代表index的大小, mat是需要替换的矩阵*index:矩阵中的行标的一维数组num:index动态数组长度mat:需要替换的矩阵*/Matrix& ReplaceRow(int* index, int num, Matrix& mat);/*函数名称:替换矩阵中行标为 index中的行，num代表index的大小, mat是需要替换的矩阵*index:矩阵中的行标的一动态维数组num:index动态数组长度mat:需要替换的矩阵*/Matrix& ReplaceRow(std::vector index, int num, Matrix& mat);/*函数名称:替换矩阵中列标为 index中的列，num代表index的大小, mat是需要替换的矩阵*index:矩阵中的列标的一维数组num:index动态数组长度mat:需要替换的矩阵*/Matrix& ReplaceCol(int* index, int num, Matrix& mat);/*函数名称:替换矩阵中列标为 index中的列，num代表index的大小, mat是需要替换的矩阵*index:矩阵中的列标的一维动态数组num:index动态数组长度mat:需要替换的矩阵*/Matrix& ReplaceCol(std::vector index, int num, Matrix& mat);Matrix.cpp函数实现文件：
//****************矩阵保留与剔除**************////剔除矩阵的 index中的行与列，num代表index的大小Matrix& Matrix::DeleteMat(int* index, int num){//结果矩阵Matrix* resMat = new Matrix(this->m_Row - num, this->m_Col - num);int recIndex[MAX_COUNT];int currIndex = 0;//检验数据有效性for (int i = 0; i = this->m_Row){std::cout << \"Error: Input index[\" << i << \"] = \" << index[i] <= m_Row\" <= this->m_Col){std::cout << \"Error: Input index[\" << i << \"] = \" << index[i] <= m_Col\" << std::endl;return *this;}}//筛选出剔除后行数for (int iRow = 0; iRow m_Row; iRow++){for (int iNum = 0; iNum < num; iNum++){if (iRow == index[iNum]){break;}if (iNum == num-1){recIndex[currIndex++] = iRow;}}}//加入元素for (int iRow = 0; iRow m_Row; iRow++){for (int iCol = 0; iCol m_Col; iCol++){resMat->m_Matrix[iRow][iCol] = this->m_Matrix[recIndex[iRow]][recIndex[iCol]];}}return *resMat;}Matrix& Matrix::DeleteMat(std::vector index, int num){//结果矩阵Matrix* resMat = new Matrix(this->m_Row - num, this->m_Col - num);int recIndex[MAX_COUNT];int currIndex = 0;//检验数据有效性for (int i = 0; i = this->m_Row){std::cout << \"Error: Input index[\" << i << \"] = \" << index[i] <= m_Row\" <= this->m_Col){std::cout << \"Error: Input index[\" << i << \"] = \" << index[i] <= m_Col\" << std::endl;return *this;}}//筛选出剔除后行数for (int iRow = 0; iRow m_Row; iRow++){for (int iNum = 0; iNum < num; iNum++){if (iRow == index[iNum]){break;}if (iNum == num - 1){recIndex[currIndex++] = iRow;}}}//加入元素for (int iRow = 0; iRow m_Row; iRow++){for (int iCol = 0; iCol m_Col; iCol++){resMat->m_Matrix[iRow][iCol] = this->m_Matrix[recIndex[iRow]][recIndex[iCol]];}}return *resMat;}//剔除矩阵的 index中的行，num代表index的大小Matrix& Matrix::DeleteRow(int* index, int num){//结果矩阵Matrix* resMat = new Matrix(this->m_Row - num, this->m_Col);int recIndex[MAX_COUNT];int currIndex = 0;//检验数据有效性for (int i = 0; i = this->m_Row){std::cout << \"Error: Input index[\" << i << \"] = \" << index[i] <= m_Row\" << std::endl;return *this;}}//筛选出剔除后行数for (int iRow = 0; iRow m_Row; iRow++){for (int iNum = 0; iNum < num; iNum++){if (iRow == index[iNum]){break;}if (iNum == num - 1){recIndex[currIndex++] = iRow;}}}//加入元素for (int iRow = 0; iRow m_Row; iRow++){for (int iCol = 0; iCol m_Col; iCol++){resMat->m_Matrix[iRow][iCol] = this->m_Matrix[recIndex[iRow]][iCol];}}return *resMat;}Matrix& Matrix::DeleteRow(std::vector index, int num){//结果矩阵Matrix* resMat = new Matrix(this->m_Row - num, this->m_Col);int recIndex[MAX_COUNT];int currIndex = 0;//检验数据有效性for (int i = 0; i = this->m_Row){std::cout << \"Error: Input index[\" << i << \"] = \" << index[i] <= m_Row\" << std::endl;return *this;}}//筛选出剔除后行数for (int iRow = 0; iRow m_Row; iRow++){for (int iNum = 0; iNum < num; iNum++){if (iRow == index[iNum]){break;}if (iNum == num - 1){recIndex[currIndex++] = iRow;}}}//加入元素for (int iRow = 0; iRow m_Row; iRow++){for (int iCol = 0; iCol m_Col; iCol++){resMat->m_Matrix[iRow][iCol] = this->m_Matrix[recIndex[iRow]][iCol];}}return *resMat;}Matrix& Matrix::DeleteCol(int* index, int num){//结果矩阵Matrix* resMat = new Matrix(this->m_Row, this->m_Col - num);int recIndex[MAX_COUNT];int currIndex = 0;//检验数据有效性for (int i = 0; i = this->m_Row){std::cout << \"Error: Input index[\" << i << \"] = \" << index[i] <= m_Row\" << std::endl;return *this;}}//筛选出剔除后行数for (int iRow = 0; iRow m_Row; iRow++){for (int iNum = 0; iNum < num; iNum++){if (iRow == index[iNum]){break;}if (iNum == num - 1){recIndex[currIndex++] = iRow;}}}//加入元素for (int iRow = 0; iRow m_Row; iRow++){for (int iCol = 0; iCol m_Col; iCol++){resMat->m_Matrix[iRow][iCol] = this->m_Matrix[iRow][recIndex[iCol]];}}return *resMat;}Matrix& Matrix::DeleteCol(std::vector index, int num){//结果矩阵Matrix* resMat = new Matrix(this->m_Row, this->m_Col - num);int recIndex[MAX_COUNT];int currIndex = 0;//检验数据有效性for (int i = 0; i = this->m_Row){std::cout << \"Error: Input index[\" << i << \"] = \" << index[i] <= m_Row\" << std::endl;return *this;}}//筛选出剔除后行数for (int iRow = 0; iRow m_Row; iRow++){for (int iNum = 0; iNum < num; iNum++){if (iRow == index[iNum]){break;}if (iNum == num - 1){recIndex[currIndex++] = iRow;}}}//加入元素for (int iRow = 0; iRow m_Row; iRow++){for (int iCol = 0; iCol m_Col; iCol++){resMat->m_Matrix[iRow][iCol] = this->m_Matrix[iRow][recIndex[iCol]];}}return *resMat;}//******************矩阵的替换****************////替换矩阵中的行和列 index中的行与列，num代表index的大小Matrix& Matrix::ReplaceMat(int* index, int num, Matrix& mat){//错误判定 方阵if (this->m_Row != this->m_Col){std::cout << \"Error: this m_Col != m_Row\" << std::endl;return *this;}//检验插入矩阵为方阵if (mat.m_Row != mat.m_Col){std::cout << \"Error: mat m_Col != m_Row\" << std::endl;return *this;}//检验插入矩阵大小与num保持一致if (mat.m_Col != num){std::cout << \"Error: num != mat.m_Col\" << std::endl;return *this;}//检验数据有效性for (int i = 0; i = this->m_Row){std::cout << \"Error: Input index[\" << i << \"] = \" << index[i] <= m_Row\" <= this->m_Col){std::cout << \"Error: Input index[\" << i << \"] = \" << index[i] <= m_Col\" << std::endl;return *this;}}//结果矩阵Matrix* resMat = new Matrix(*this);//加入元素for (int iRow = 0; iRow < num; iRow++){for (int iCol = 0; iCol m_Matrix[index[iRow]][index[iCol]] = mat.m_Matrix[iRow][iCol];}}return *resMat;}Matrix& Matrix::ReplaceMat(std::vector index, int num, Matrix& mat){//错误判定 方阵if (this->m_Row != this->m_Col){std::cout << \"Error: this m_Col != m_Row\" << std::endl;return *this;}//检验插入矩阵为方阵if (mat.m_Row != mat.m_Col){std::cout << \"Error: mat m_Col != m_Row\" << std::endl;return *this;}//检验插入矩阵大小与num保持一致if (mat.m_Col != num){std::cout << \"Error: num != mat.m_Col\" << std::endl;return *this;}//检验数据有效性for (int i = 0; i = this->m_Row){std::cout << \"Error: Input index[\" << i << \"] = \" << index[i] <= m_Row\" <= this->m_Col){std::cout << \"Error: Input index[\" << i << \"] = \" << index[i] <= m_Col\" << std::endl;return *this;}}//结果矩阵Matrix* resMat = new Matrix(*this);//加入元素for (int iRow = 0; iRow < num; iRow++){for (int iCol = 0; iCol m_Matrix[index[iRow]][index[iCol]] = mat.m_Matrix[iRow][iCol];}}return *resMat;}//替换矩阵中的行 index中的行，num代表index的大小, mat是需要替换的矩阵Matrix& Matrix::ReplaceRow(int* index, int num, Matrix& mat){//检验插入矩阵大小与num保持一致if (mat.m_Row != num){std::cout << \"Error: num != mat.m_Row\" << std::endl;return *this;}//检验数据有效性for (int i = 0; i = this->m_Row){std::cout << \"Error: Input index[\" << i << \"] = \" << index[i] <= m_Row\" <m_Col != mat.m_Col){std::cout << \"Error: this->m_Col != mat.m_Col\" << std::endl;return *this;}//结果矩阵Matrix* resMat = new Matrix(*this);//加入元素for (int iRow = 0; iRow < num; iRow++){for (int iCol = 0; iCol m_Col; iCol++){resMat->m_Matrix[index[iRow]][iCol] = mat.m_Matrix[iRow][iCol];}}return *resMat;}Matrix& Matrix::ReplaceRow(std::vector index, int num, Matrix& mat){//检验插入矩阵大小与num保持一致if (mat.m_Row != num){std::cout << \"Error: num != mat.m_Row\" << std::endl;return *this;}//检验数据有效性for (int i = 0; i = this->m_Row){std::cout << \"Error: Input index[\" << i << \"] = \" << index[i] <= m_Row\" <m_Col != mat.m_Col){std::cout << \"Error: this->m_Col != mat.m_Col\" << std::endl;return *this;}//结果矩阵Matrix* resMat = new Matrix(*this);//加入元素for (int iRow = 0; iRow < num; iRow++){for (int iCol = 0; iCol m_Col; iCol++){resMat->m_Matrix[index[iRow]][iCol] = mat.m_Matrix[iRow][iCol];}}return *resMat;}//替换矩阵中的列 index中的列，num代表index的大小, mat是需要替换的矩阵Matrix& Matrix::ReplaceCol(int* index, int num, Matrix& mat){//检验插入矩阵大小与num保持一致if (mat.m_Col != num){std::cout << \"Error: mat.m_Col != num\" << std::endl;return *this;}//检验数据有效性for (int i = 0; i = this->m_Col){std::cout << \"Error: Input index[\" << i << \"] = \" << index[i] <= m_Col\" <m_Row != mat.m_Row){std::cout << \"Error: this->m_Row != mat.m_Row\" << std::endl;return *this;}//结果矩阵Matrix* resMat = new Matrix(*this);//加入元素for (int iRow = 0; iRow m_Row; iRow++){for (int iCol = 0; iCol m_Matrix[iRow][index[iCol]] = mat.m_Matrix[iRow][iCol];}}return *resMat;}Matrix& Matrix::ReplaceCol(std::vector index, int num, Matrix& mat){//检验插入矩阵大小与num保持一致if (mat.m_Col != num){std::cout << \"Error: mat.m_Col != num\" << std::endl;return *this;}//检验数据有效性for (int i = 0; i = this->m_Col){std::cout << \"Error: Input index[\" << i << \"] = \" << index[i] <= m_Col\" <m_Row != mat.m_Row){std::cout << \"Error: this->m_Row != mat.m_Row\" << std::endl;return *this;}//结果矩阵Matrix* resMat = new Matrix(*this);//加入元素for (int iRow = 0; iRow m_Row; iRow++){for (int iCol = 0; iCol m_Matrix[iRow][index[iCol]] = mat.m_Matrix[iRow][iCol];}}return *resMat;}测试验证：
测试代码：
int main(){//定义矩阵数值double tempValue[9] = {1.0, 2.0, 3.0,4.0, 5.0, 6.0,7.0, 8.0, 0.0};//替换数值double replaceValue[3] = {1.42, 2.54, 9.65};//创建矩阵Matrix* tempMatrix = new Matrix(3, 3, tempValue);Matrix* tempReplaceMatrix = new Matrix(1, 3, replaceValue);int replaceCol[1] = {2};//打印矩阵std::cout << \"数值第3行替换前:\" <PrintMat();//打印矩阵(注意可链式编程)std::cout << \"数值第3行替换后:\" <ReplaceRow(replaceCol, 1, *tempReplaceMatrix).PrintMat();//打印矩阵std::cout << \"数值第3行删除前:\" <PrintMat();//打印矩阵(注意可链式编程)std::cout << \"数值第3行删除后:\" <DeleteRow(replaceCol, 1).PrintMat();system(\"pause\");return 0;}应用输出：
数值第3行替换前:1.000000e+00 2.000000e+00 3.000000e+004.000000e+00 5.000000e+00 6.000000e+007.000000e+00 8.000000e+00 0.000000e+00数值第3行替换后:1.000000e+00 2.000000e+00 3.000000e+004.000000e+00 5.000000e+00 6.000000e+001.420000e+00 2.540000e+00 9.650000e+00数值第3行删除前:1.000000e+00 2.000000e+00 3.000000e+004.000000e+00 5.000000e+00 6.000000e+007.000000e+00 8.000000e+00 0.000000e+00数值第3行删除后:1.000000e+00 2.000000e+00 3.000000e+004.000000e+00 5.000000e+00 6.000000e+00请按任意键继续. . .1.6、矩阵初等变换
可实现矩阵的初等变化，注意返回值类型为自身的引用，可实现链式编程。
Matrix.h声明文件：
//*****************矩阵初等变化***************///*函数名称:交换矩阵中行标为row0与row1的元素row0:矩阵行标0row1:矩阵行标1*/Matrix& SwapRow(int row0, int row1);/*函数名称:交换矩阵中列标为col0与col1的元素col0:矩阵列标0col1:矩阵列标1*/Matrix& SwapCol(int col0, int col1);/*函数名称:矩阵行加法 rowLocal = rowLocal + rate *rowAddrowLocal:矩阵行标，被加数rowAdd:矩阵行标，加数rate:加数前倍数*/Matrix& AddRow(int rowLocal, int rowAdd, double rate = 1.0);//矩阵加法 某列 + 倍数*某列/*函数名称:矩阵列加法 colLocal = colLocal + rate * colAddcolLocal:矩阵列标，被加数colAdd:矩阵列标，加数rate:加数前倍数*/Matrix& AddCol(int colLocal, int colAdd, double rate = 1.0);//*******************矩阵加法*****************///*函数名称:矩阵加法 本矩阵 = 本矩阵 + mat 前提是两个矩阵维度一致mat:加数矩阵*/Matrix& AddMat(Matrix& mat);Matrix.cpp函数实现文件：
//*****************矩阵初等变化***************//Matrix& Matrix::SwapRow(int row0, int row1){//错误判定 越界if ((this->m_Row m_Col <= row1)){std::cout << \"Error: Input row0 Or row1 More Than m_Row\" < row0) || (0 > row1)){std::cout << \"Error: Input row0 Or row1 Less 0\" << std::endl;return *this;}else{//结果矩阵初始化Matrix* resMat = new Matrix(*this);//中转临时变量double temp = 0.0;for (int j = 0; j m_Col; j++){temp = resMat->m_Matrix[row0][j];resMat->m_Matrix[row0][j] = resMat->m_Matrix[row1][j];resMat->m_Matrix[row1][j] = temp;}return*resMat;}}Matrix& Matrix::SwapCol(int col0, int col1){//错误判定 越界if ((this->m_Col m_Col <= col1)){std::cout << \"Error: Input col0 Or col1 More Than m_Col\" < col0) || (0 > col1)){std::cout << \"Error: Input col0 Or col1 Less 0\" << std::endl;return *this;}else{//结果矩阵初始化Matrix* resMat = new Matrix(*this);//中转临时变量double temp = 0.0;for (int i = 0; i m_Row; i++){temp = resMat->m_Matrix[i][col0];resMat->m_Matrix[i][col0] = resMat->m_Matrix[i][col1];resMat->m_Matrix[i][col1] = temp;}return*resMat;}}//矩阵加法 某行 + 倍数*某行Matrix& Matrix::AddRow(int rowLocal, int rowAdd, double rate){if ((this->m_Row m_Row <= rowAdd)){std::cout << \"Error: Input rowLocal Or rowAdd More Than m_Row\" < rowLocal) || (0 > rowAdd)){std::cout << \"Error: Input rowLocal Or rowAdd Less 0\" << std::endl;return *this;}else{//结果矩阵初始化Matrix* resMat = new Matrix(*this);//指定行相加for (int j = 0; j m_Col; j++){resMat->m_Matrix[rowLocal][j] += rate * resMat->m_Matrix[rowAdd][j];}return *resMat;}}//矩阵加法 某列 + 倍数*某列Matrix& Matrix::AddCol(int colLocal, int colAdd, double rate){if ((this->m_Col m_Col <= colAdd)){std::cout << \"Error: Input colLocal Or colAdd More Than m_Col\" < colLocal) || (0 > colAdd)){std::cout << \"Error: Input colLocal Or colAdd Less 0\" << std::endl;return *this;}else{//结果矩阵初始化Matrix* resMat = new Matrix(*this);//指定列相加for (int i = 0; i m_Row; i++){resMat->m_Matrix[i][colLocal] += rate * resMat->m_Matrix[i][colAdd];}return *resMat;}}测试验证：
测试代码：
int main(){//定义矩阵数值double tempValue[9] = {1.0, 2.0, 3.0,4.0, 5.0, 6.0,7.0, 8.0, 0.0};//创建矩阵Matrix* tempMatrix = new Matrix(3, 3, tempValue);//打印矩阵std::cout << \"************************\" << std::endl;std::cout << \"数值第1行与第3行交换前:\" <PrintMat();//打印矩阵(注意可链式编程)std::cout << \"数值第1行与第3行交换后:\" <SwapRow(0, 2).PrintMat();//打印矩阵std::cout << \"************************\" << std::endl;std::cout << \"数值第1行与第3行相加前:\" <PrintMat();//打印矩阵(注意可链式编程)std::cout << \"数值第1行与第3行相加后:\" <AddRow(0, 2).PrintMat();system(\"pause\");return 0;}应用输出：
************************数值第1行与第3行交换前:1.000000e+00 2.000000e+00 3.000000e+004.000000e+00 5.000000e+00 6.000000e+007.000000e+00 8.000000e+00 0.000000e+00数值第1行与第3行交换后:7.000000e+00 8.000000e+00 0.000000e+004.000000e+00 5.000000e+00 6.000000e+001.000000e+00 2.000000e+00 3.000000e+00************************数值第1行与第3行相加前:1.000000e+00 2.000000e+00 3.000000e+004.000000e+00 5.000000e+00 6.000000e+007.000000e+00 8.000000e+00 0.000000e+00数值第1行与第3行相加后:8.000000e+00 1.000000e+01 3.000000e+004.000000e+00 5.000000e+00 6.000000e+007.000000e+00 8.000000e+00 0.000000e+00请按任意键继续. . .1.7、矩阵加法
实现矩阵基本加法，注意返回值类型为自身的引用，可实现链式编程。
Matrix.h声明文件：
//*******************矩阵加法*****************///*函数名称:矩阵加法 本矩阵 = 本矩阵 + mat 前提是两个矩阵维度一致mat:加数矩阵*/Matrix& AddMat(Matrix& mat);Matrix.cpp函数实现文件：
//*******************矩阵加法*****************//Matrix& Matrix::AddMat(Matrix& mat){Matrix* ResMat = new Matrix(*this);for (int i = 0; i m_Row; i++){for (int j = 0; j m_Col; j++){ResMat->m_Matrix[i][j] += mat.m_Matrix[i][j];}}return *ResMat;}测试验证：
测试代码：
int main(){//定义矩阵数值double tempValue0[9] = {1.0, 2.0, 3.0,4.0, 5.0, 6.0,7.0, 8.0, 0.0};//定义矩阵数值double tempValue1[9] = {2.0, 5.0, 8.0,1.0, 5.0, 9.0,3.0, 6.0, 7.0};//创建矩阵Matrix* tempMatrix0 = new Matrix(3, 3, tempValue0);Matrix* tempMatrix1 = new Matrix(3, 3, tempValue1);//打印矩阵std::cout << \"************************\" << std::endl;std::cout << \"数值矩阵相加前:\" <PrintMat();//打印矩阵(注意可链式编程)std::cout << \"数值矩阵相加后:\" <AddMat(*tempMatrix1).PrintMat();system(\"pause\");return 0;}应用输出：
************************数值矩阵相加前:1.000000e+00 2.000000e+00 3.000000e+004.000000e+00 5.000000e+00 6.000000e+007.000000e+00 8.000000e+00 0.000000e+00数值矩阵相加后:3.000000e+00 7.000000e+00 1.100000e+015.000000e+00 1.000000e+01 1.500000e+011.000000e+01 1.400000e+01 7.000000e+00请按任意键继续. . .1.8、矩阵乘法
实现矩阵基本乘法，注意返回值类型为自身的引用，可实现链式编程。
Matrix.h声明文件：
//*******************矩阵乘法*****************///*函数名称:矩阵乘法 本矩阵 = 本矩阵*num num:矩阵乘数*/Matrix& MultNum(double num);/*函数名称:矩阵乘法（运算符重载） 本矩阵 = 本矩阵*num num:矩阵乘数*/Matrix& operator * (double num);/*函数名称:矩阵某行乘数值row = row*numnum:矩阵某列乘数row:矩阵行标*/Matrix& MultRow(double num, int row);/*函数名称:矩阵某列乘数值col = col *numnum:矩阵某列乘数col:矩阵列标*/Matrix& MultCol(double num, int col);/*函数名称:矩阵乘法，按照矩阵相乘规则inputMat:乘数矩阵*/Matrix& MultMat(Matrix& inputMat);Matrix.cpp函数实现文件：
//*******************矩阵乘法*****************////矩阵数乘Matrix& Matrix::MultNum(double num){//结果矩阵初始化Matrix* resMat = new Matrix(this->m_Row, this->m_Col);//乘后矩阵生成for (int i = 0; i m_Row; i++){for (int j = 0; j m_Col; j++){resMat->m_Matrix[i][j] = num * this->m_Matrix[i][j];}}return *resMat;}//运算符重载 矩阵数乘Matrix& Matrix::operator*(double num){//结果矩阵初始化Matrix* resMat = new Matrix(this->m_Row, this->m_Col);//乘后矩阵生成for (int i = 0; i m_Row; i++){for (int j = 0; j m_Col; j++){resMat->m_Matrix[i][j] = num * this->m_Matrix[i][j];}}return *resMat;}//矩阵某行乘数值 行标从0开始计数Matrix& Matrix::MultRow(double num, int row){if (this->m_Row <= row){std::cout << \"Error: Input row More Than m_Row\" < row){std::cout << \"Error: Input row Less 0\" << std::endl;return *this;}else{//结果矩阵初始化Matrix* resMat = new Matrix(*this);//乘后矩阵生成for (int j = 0; j m_Col; j++){resMat->m_Matrix[row][j] = num * this->m_Matrix[row][j];}return *resMat;}}//矩阵某列乘数值 列标从0开始计数Matrix& Matrix::MultCol(double num, int col){if (this->m_Col <= col){std::cout << \"Error: Input col More Than m_Row\" < col){std::cout << \"Error: Input col Less 0\" << std::endl;return *this;}else{//结果矩阵初始化Matrix* resMat = new Matrix(*this);//乘后矩阵生成for (int i = 0; i m_Row; i++){resMat->m_Matrix[i][col] = num * this->m_Matrix[i][col];}return *resMat;}}//矩阵相乘Matrix& Matrix::MultMat(Matrix& inputMat){Matrix *resMat = new Matrix(this->m_Row, inputMat.m_Col);if (this->m_Col != inputMat.m_Row){std::cout << \"Matrix Mult Error!\" << std::endl;return *resMat;}else{for (int i = 0; i m_Row; i++){for (int j = 0; j < inputMat.m_Col; j++){for (int k = 0; k m_Col; k++){resMat->m_Matrix[i][j] += this->m_Matrix[i][k] * inputMat.m_Matrix[k][j];}}}return *resMat;}}测试验证：
测试代码：
int main(){//定义矩阵数值double tempValue0[9] = {1.0, 2.0, 3.0,4.0, 5.0, 6.0,7.0, 8.0, 0.0};//定义矩阵数值double tempValue1[9] = {2.0, 5.0, 8.0,1.0, 5.0, 9.0,3.0, 6.0, 7.0};//创建矩阵Matrix* tempMatrix0 = new Matrix(3, 3, tempValue0);Matrix* tempMatrix1 = new Matrix(3, 3, tempValue1);//打印矩阵std::cout << \"************************\" << std::endl;std::cout << \"数值矩阵相乘前:\" <PrintMat();//打印矩阵(注意可链式编程)std::cout << \"数值矩阵相乘后:\" <MultMat(*tempMatrix1).PrintMat();system(\"pause\");return 0;}应用输出：
************************数值矩阵相乘前:1.000000e+00 2.000000e+00 3.000000e+004.000000e+00 5.000000e+00 6.000000e+007.000000e+00 8.000000e+00 0.000000e+00数值矩阵相乘后:1.300000e+01 3.300000e+01 4.700000e+013.100000e+01 8.100000e+01 1.190000e+022.200000e+01 7.500000e+01 1.280000e+02请按任意键继续. . .matlab验证：
>> tempMatrix0 = [1 2 3;4 5 6; 7 8 0];>> tempMatrix1 = [2 5 8;1 5 9; 3 6 7];>> res = tempMatrix0*tempMatrix1res = 13 33 47 31 81 119 22 75 1281.9、行列式相关操作
实现行列式计算相关操作。
Matrix.h声明文件：
//******************行列式相关操作***********************///*函数名称:求解矩阵对应行列式数值，前提为方阵，按照定义求解，时间复杂度为O(n!*n)，一般不用此方法求解*/double Det();/*函数名称:求解矩阵对应行列式的顺序主子式，前提为方阵，按照定义求解，时间复杂度为O(n!*n)，一般不用此方法求解order:阶数*/double Det(int order); /*函数名称:矩阵行标为row、列标为col的余子式row:矩阵行标col:矩阵列标*/Matrix& ChildMatrix(int row, int col);/*函数名称:通过高斯列主消元求解矩阵行列式数值，最为常用*/double DetRow();Matrix.cpp函数实现文件：
//矩阵的行列式数值double Matrix::Det(){double res = 0.0;int sign = 1;if (this->m_Row != this->m_Col){//错误判定std::cout << \"Error: Matrix Col != Row\" <m_Row m_Matrix[0][0];}else{for (int i = 0; i m_Col; i++){Matrix* temp = &(this->ChildMatrix(0, i));res += sign * this->m_Matrix[0][i] * (temp->Det());sign = -1*sign;delete temp;}}}//矩阵行列式顺序主子式 order阶数double Matrix::Det(int order){if (this->m_Row != this->m_Col){//错误判定std::cout << \"Error: Matrix Col != Row\" << std::endl;return 0;}else if (order < 0){std::cout << \"Error: Input Order Less 0\" <= this->m_Row){std::cout << \"Error: Input Order More Than Row\" << std::endl;return 0;}else{Matrix tempMat(order + 1, order + 1);for (int i = 0; i < tempMat.m_Col; i++){for (int j = 0; j m_Matrix[i][j];}}return tempMat.Det();}}//求解余子式Matrix& Matrix::ChildMatrix(int row, int col){if (this->m_Row != this->m_Col){std::cout << \"Error: Matrix row != col\" <m_Row <= 1){std::cout << \"Error: Matrix Row Less 1 \" < this->m_Row) || (col > this->m_Col)){std::cout << \"Error: Input Row Or Col More Than Matix Max Row Or Col\" <m_Row-1, this->m_Col-1);for (int i = 0; i m_Row; i++){for (int j = 0; j m_Col; j++){if ((i < row) && (j 测试验证：
测试代码：
int main(){//定义矩阵数值double tempValue0[9] = {1.0, 2.0, 3.0,4.0, 5.0, 6.0,7.0, 8.0, 0.0};//创建矩阵Matrix* tempMatrix0 = new Matrix(3, 3, tempValue0);//打印矩阵std::cout << \"************************\" << std::endl;std::cout << \"高斯列主消元过程:\" << std::endl;std::cout <DetRow() << std::endl;system(\"pause\");return 0;}应用输出：
************************高斯列主消元过程:0 行交换2 行7.000000e+00 8.000000e+00 0.000000e+004.000000e+00 5.000000e+00 6.000000e+001.000000e+00 2.000000e+00 3.000000e+00 *1 行 + *0 行7.000000e+00 8.000000e+00 0.000000e+000.000000e+00 4.285714e-01 6.000000e+001.000000e+00 2.000000e+00 3.000000e+00 *2 行 + *0 行7.000000e+00 8.000000e+00 0.000000e+000.000000e+00 4.285714e-01 6.000000e+000.000000e+00 8.571429e-01 3.000000e+001 行交换2 行7.000000e+00 8.000000e+00 0.000000e+000.000000e+00 8.571429e-01 3.000000e+000.000000e+00 4.285714e-01 6.000000e+00 *2 行 + *1 行7.000000e+00 8.000000e+00 0.000000e+000.000000e+00 8.571429e-01 3.000000e+000.000000e+00 5.551115e-17 4.500000e+002.700000e+01请按任意键继续. . .Matlab验证：
>> tempMatrix0 = [1 2 3;4 5 6; 7 8 0];>> det(tempMatrix0)ans = 27.00001.10、矩阵求逆
实现矩阵求逆相关操作
Matrix.h声明文件：
//*********************矩阵求逆********************///*函数名称:矩阵求逆，按照定义求解，1/|A|*(A*)，时间复杂度为O(n!*n)，一般不用此方法*/Matrix& Inverse();/*函数名称:矩阵求逆，通过行初等变化，高斯列主消元法求解*/Matrix& InverseRow();/*函数名称:矩阵求逆，只针对于下三角矩阵进行求解*/Matrix& InverseDownTriangle();/*函数名称:矩阵求逆，只针对于上三角矩阵进行求解*/Matrix& InverseUpTriangle();//矩阵LU分解/*函数名称:矩阵LU分解LMat:矩阵分解后的L矩阵UMat:矩阵分解后的U矩阵*/void ResolveLU(Matrix& LMat, Matrix& UMat);/*函数名称:矩阵的LUP分解 P*A = L*U 添加了列主消元功能LMat:矩阵分解后的L矩阵UMat:矩阵分解后的U矩阵PMat:矩阵分解后的P矩阵*/void ResolveLUP(Matrix& LMat, Matrix& UMat, Matrix& PMat);Matrix.cpp函数实现文件：
//矩阵求逆Matrix& Matrix::Inverse(){if (abs(this->DetRow()) < MIN_DET){std::cout << \"Error: Matrix Det Near 0\" <m_Row, this->m_Col);for (int i = 0; i m_Row; i++){for (int j = 0; j m_Col; j++){Matrix* temp = &(this->ChildMatrix(j, i));resMat->m_Matrix[i][j] = pow(-1.0, (i + j)) / this->DetRow() * (temp->DetRow());delete temp;}}return *resMat;}}//矩阵求逆 行初等变化Matrix& Matrix::InverseRow(){//错误判断if (abs(this->DetRow()) < MIN_DET){std::cout << \"Error: Matrix Det Near 0\" <m_Row <= 1){std::cout << \"Error: Size Less 2\" <Uint();//结果矩阵 逆矩阵 初始状态与本矩阵相同 为不使本矩阵发生改变Matrix temp(this->m_Row, this->m_Col);Matrix* resMat = new Matrix(temp.Uint());//本矩阵Matrix localMat(*this);//*******************通过交换 num1*i + num2*j 实现下三角为0***************//for (int i = 0; i < localMat.m_Row - 1; i++){//记录最大行所在行标int tempMaxRow = i;for (int i1 = i + 1; i1 abs(localMat.m_Matrix[tempMaxRow][i])){tempMaxRow = i1;}}if (tempMaxRow != i){//std::cout << i << \" 行交换\" << tempMaxRow << \" 行\" <SwapRow(i, tempMaxRow);//localMat.PrintMat();}//此对角线以下的元素通过初等变化为0for (int i2 = i + 1; i2 < localMat.m_Row; i2++){if (localMat.m_Matrix[i2][i] != 0){//std::cout << \"<\" << localMat.m_Matrix[i][i] < *\" << i2 << \" 行 + <\" << -1.0 * (localMat.m_Matrix[i2][i]) < *\" << i << \" 行\" <AddRow(i2, i, -1.0 * (localMat.m_Matrix[i2][i]) / localMat.m_Matrix[i][i]);localMat = localMat.AddRow(i2, i, -1.0 * (localMat.m_Matrix[i2][i]) / localMat.m_Matrix[i][i]);//localMat.PrintMat();}}}//错误判断if (localMat.m_Matrix[localMat.m_Row - 1][localMat.m_Col - 1] == 0){std::cout << \"Error: marix[\" << localMat.m_Row - 1 << \"][\" << localMat.m_Col - 1 <<\"] == 0\" < 0; i--){for (int i2 = i - 1; i2 >= 0; i2--){if (localMat.m_Matrix[i2][i] != 0){//std::cout << \"<\" << localMat.m_Matrix[i][i] < *\" << i2 << \" 行 + <\" << -1.0 * (localMat.m_Matrix[i2][i]) < *\" << i << \" 行\" <AddRow(i2, i, -1.0 * (localMat.m_Matrix[i2][i]) / localMat.m_Matrix[i][i]);localMat = localMat.AddRow(i2, i, -1.0 * (localMat.m_Matrix[i2][i]) / localMat.m_Matrix[i][i]);//localMat.PrintMat();}}}//*******************通过 i*num 实现矩阵为单位矩阵***************//for (int i = 0; i < localMat.m_Row; i++){if (localMat.m_Matrix[i][i] == 0){std::cout << \"Error: matrix[\" << i << \"]\" << \"[\" << i << \"] == 0\" << std::endl;return *this;}else{//std::cout << \"<\" << 1 / localMat.m_Matrix[i][i] < *\" << i << \" 行\" <MultRow(1 / localMat.m_Matrix[i][i], i);localMat = localMat.MultRow(1 / localMat.m_Matrix[i][i], i);//localMat.PrintMat();}}return *resMat;}}//矩阵求逆 下三角矩阵Matrix& Matrix::InverseDownTriangle(){//错误判断 方阵检测if (this->m_Row != this->m_Col){std::cout << \"Error: Matrix Col != Row\" << std::endl;return *this;}//下三角求逆Matrix* resMat = new Matrix(*this);for (int i = 0; i m_Row; i++){for (int j = 0; j m_Matrix[i][j] = 1 / resMat->m_Matrix[i][j];}else{//分段求解 非对角线元素 double tempSum = 0.0;for (int k = j; k m_Matrix[i][k] * resMat->m_Matrix[k][j];}resMat->m_Matrix[i][j] = -1.0*tempSum / resMat->m_Matrix[i][i];}}}return *resMat;}//矩阵求逆 上三角矩阵Matrix& Matrix::InverseUpTriangle(){//错误判断 方阵检测if (this->m_Row != this->m_Col){std::cout << \"Error: Matrix Col != Row\" <m_Col-1; j >=0; j--){for (int i = j; i >=0; i--){//分段求解 对角线为倒数if (i == j){resMat->m_Matrix[i][j] = 1 / resMat->m_Matrix[i][j];}else{//分段求解 非对角线元素 double tempSum = 0.0;for (int k = j; k >= i+1; k--){tempSum += resMat->m_Matrix[i][k] * resMat->m_Matrix[k][j];}resMat->m_Matrix[i][j] = -1.0 * tempSum / resMat->m_Matrix[i][i];}}}return *resMat;}//矩阵LU分解 顺序分解 对于病态矩阵可能存在精度问题void Matrix::ResolveLU(Matrix& LMat, Matrix& UMat){if (this->m_Col != this->m_Row){std::cout << \"Error: Is Not Square Matrix\" << std::endl;return;}//存在性判定 顺序主子式不为0for (int i = 0; i m_Row; i++){if (this->Det(i) == 0){std::cout << \"Error: order Det = 0\" <Uint();//U矩阵初始化为空矩阵Matrix temp(this->m_Row, this->m_Col);UMat = temp;for (int i = 0; i m_Row; i++){//计算Ufor (int j1 = i; j1 m_Col; j1++){double tempSum1 = 0.0;if (i != 0){for (int j2 = 0; j2 m_Matrix[i][j1] - tempSum1;}//计算Lfor (int i1 = i; i1 m_Row; i1++){double tempSum2 = 0.0;if (i != 0){for (int j2 = 0; j2 m_Matrix[i1][i] - tempSum2)/UMat.m_Matrix[i][i];}}}//矩阵的LUP分解 P*A = L*U 添加了列主消元功能 //L为主对角线元素为1的下三角矩阵 U为上二角矩阵 P为行交换矩阵 P*A=L*Uvoid Matrix::ResolveLUP(Matrix& LMat, Matrix& UMat, Matrix& PMat){//条件判断 矩阵行列式不为0if (this->Det() == 0){std::cout << \"Error: Can\'t Resolve Matrix To L U P\" <Uint();PMat = this->Uint();UMat = *this;//进行分解计算for (int i = 0; i < UMat.m_Row - 1; i++){//记录最大行所在行标int tempMaxRow = i;for (int i1 = i + 1; i1 abs(UMat.m_Matrix[tempMaxRow][i])){tempMaxRow = i1;}}//进行交换 将当前第i行与第tempMaxRow行进行互换 初等行变换UMat = UMat.SwapRow(i, tempMaxRow);//L矩阵做出对应交换 先交换列再交换行LMat = LMat.SwapCol(i, tempMaxRow);LMat = LMat.SwapRow(i, tempMaxRow);//P矩阵做出对应变换 交换行PMat = PMat.SwapRow(i, tempMaxRow);//高斯消元 V矩阵消除下三角区域，L矩阵添加下三角区域for (int i1 = i + 1; i1 < UMat.m_Row; i1++){//记录消元系数double deleteVar = UMat.m_Matrix[i1][i] / UMat.m_Matrix[i][i];//L矩阵列填充LMat.m_Matrix[i1][i] = deleteVar;//U矩阵列消除UMat = UMat.MultRow(UMat.m_Matrix[i][i], i1).AddRow(i1, i, -1.0 * UMat.m_Matrix[i1][i]).MultRow(1 / UMat.m_Matrix[i][i], i1);}}return;}测试验证：
测试代码：
int main(){//定义矩阵数值double tempValue0[9] = {1.0, 2.0, 3.0,4.0, 5.0, 6.0,7.0, 8.0, 0.0};//创建矩阵Matrix* tempMatrix0 = new Matrix(3, 3, tempValue0);Matrix* tempMatrix0L = new Matrix(3, 3);Matrix* tempMatrix0U = new Matrix(3, 3);Matrix* tempMatrix0P = new Matrix(3, 3);//打印矩阵std::cout << \"************************\" << std::endl;std::cout << \"矩阵求逆前:\" <PrintMat();std::cout << \"矩阵求逆后:\" <InverseRow().PrintMat();std::cout << \"求逆验证:\" <MultMat(tempMatrix0->InverseRow()).PrintMat();std::cout << \"************************\" << std::endl;std::cout << \"矩阵LU分解前:\" <PrintMat();std::cout << \"矩阵LU分解后:\" <ResolveLUP(*tempMatrix0L, *tempMatrix0U, *tempMatrix0P);std::cout << \"矩阵L:\" <PrintMat();std::cout << \"矩阵U:\" <PrintMat();std::cout << \"矩阵P:\" <PrintMat();system(\"pause\");return 0;}应用输出：
************************矩阵求逆前:1.000000e+00 2.000000e+00 3.000000e+004.000000e+00 5.000000e+00 6.000000e+007.000000e+00 8.000000e+00 0.000000e+00矩阵求逆后:-1.777778e+00 8.888889e-01 -1.111111e-011.555556e+00 -7.777778e-01 2.222222e-01-1.111111e-01 2.222222e-01 -1.111111e-01求逆验证:1.000000e+00 -1.110223e-16 0.000000e+00-2.220446e-16 1.000000e+00 0.000000e+001.776357e-15 -8.881784e-16 1.000000e+00************************矩阵LU分解前:1.000000e+00 2.000000e+00 3.000000e+004.000000e+00 5.000000e+00 6.000000e+007.000000e+00 8.000000e+00 0.000000e+00矩阵LU分解后:矩阵L:1.000000e+00 0.000000e+00 0.000000e+001.428571e-01 1.000000e+00 0.000000e+005.714286e-01 5.000000e-01 1.000000e+00矩阵U:7.000000e+00 8.000000e+00 0.000000e+000.000000e+00 8.571429e-01 3.000000e+000.000000e+00 0.000000e+00 4.500000e+00矩阵P:0.000000e+00 0.000000e+00 1.000000e+001.000000e+00 0.000000e+00 0.000000e+000.000000e+00 1.000000e+00 0.000000e+00请按任意键继续. . .matlab验证：
>> tempMatrix0 = [1 2 3; 4 5 6; 7 8 0];>> tempMatrix0^-1ans = -1.7778 0.8889 -0.1111 1.5556 -0.7778 0.2222 -0.1111 0.2222 -0.1111>> [L, U, P] = lu(tempMatrix0)L = 1.0000 0 0 0.1429 1.0000 0 0.5714 0.5000 1.0000U = 7.0000 8.0000 0 0 0.8571 3.0000 0 0 4.5000P = 0 0 1 1 0 0 0 1 02、private variable
私有成员变量
double** m_Matrix;//矩阵int m_Row;//矩阵行数int m_Col;//矩阵列数3、全部源码
为了方便大家复制应用，这里直接贴出源码
Matrix.h声明文件：
#ifndef _MATRIX_H_#define _MATRIX_H_#include #include #include //矩阵最大容量#define MAX_COUNT 500#define MIN_DET 1e-12//行列式最小数值class Matrix{public://******************************构造函数与析构函数********************************///*函数名称:无参构造函数*/Matrix();/*函数名称:矩阵有参构造函数，初始化为row行、col列的0矩阵row:矩阵行数col:矩阵列数*/Matrix(int row, int col);/*函数名称:矩阵有参构造函数，初始化为row行、col列、数值为mat的矩阵row:矩阵行数col:矩阵列数*mat:矩阵数值一维数组*/Matrix(int row, int col, double* mat);/*函数名称:深拷贝构造函数mat:需要复制的矩阵*/Matrix(const Matrix& mat);/*函数名称:析构函数*/~Matrix();//*******************获取矩阵*****************///*函数名称:获取矩阵的第row行、第col列元素数值row:矩阵行数col:矩阵列数*/double GetMatrixEle(int row, int col);//*******************设置矩阵*****************///*函数名称:设置矩阵第row行、第col列数值row:矩阵行数col:矩阵列数value:设置的矩阵数值*/void SetMatrixEle(int row, int col, double value);/*函数名称:深拷贝矩阵mat:需要复制的矩阵*/Matrix CopyMat(const Matrix mat);//********************************矩阵的相关计算**********************************////*******************打印矩阵*****************///*函数名称:打印矩阵*/void PrintMat();//*****************矩阵基本操作***************///*函数名称:矩阵转置，返回的是自身引用，可链式调用*/Matrix& Transpose();/*函数名称:等维度的单位矩阵，前提是方阵*/Matrix& Uint();//****************矩阵保留与剔除**************///*函数名称:剔除矩阵中以index为行标和列标的行和列，num代表index的大小*index:矩阵中的行号与列号一维数组num:index动态数组长度*/Matrix& DeleteMat(int *index, int num);/*函数名称:剔除矩阵中以index为行标和列标的行和列，num代表index的大小*index:矩阵中的行号与列号一维动态数组num:index动态数组长度*/Matrix& DeleteMat(std::vector index, int num);/*函数名称:剔除矩阵中以index为行标的行，num代表index的大小*index:矩阵中的行号一维数组num:index动态数组长度*/Matrix& DeleteRow(int* index, int num);/*函数名称:剔除矩阵中以index为行标的行，num代表index的大小*index:矩阵中的行号一维动态数组num:index动态数组长度*/Matrix& DeleteRow(std::vector index, int num);/*函数名称:剔除矩阵中以index为列标的列，num代表index的大小*index:矩阵中的列号一维数组num:index动态数组长度*/Matrix& DeleteCol(int* index, int num);/*函数名称:剔除矩阵中以index为列标的列，num代表index的大小*index:矩阵中的列号一维动态数组num:index动态数组长度*/Matrix& DeleteCol(std::vector index, int num);//******************矩阵的替换****************///*函数名称:替换矩阵中行标和列标为 index中的行与列，num代表index的大小, mat是需要替换的矩阵*index:矩阵中的行标和列标的一维数组num:index动态数组长度mat:需要替换的矩阵*/Matrix& ReplaceMat(int* index, int num, Matrix& mat);/*函数名称:替换矩阵中行标和列标为 index中的行与列，num代表index的大小, mat是需要替换的矩阵*index:矩阵中的行标和列标的一维动态数组num:index动态数组长度mat:需要替换的矩阵*/Matrix& ReplaceMat(std::vector index, int num, Matrix& mat);/*函数名称:替换矩阵中行标为 index中的行，num代表index的大小, mat是需要替换的矩阵*index:矩阵中的行标的一维数组num:index动态数组长度mat:需要替换的矩阵*/Matrix& ReplaceRow(int* index, int num, Matrix& mat);/*函数名称:替换矩阵中行标为 index中的行，num代表index的大小, mat是需要替换的矩阵*index:矩阵中的行标的一动态维数组num:index动态数组长度mat:需要替换的矩阵*/Matrix& ReplaceRow(std::vector index, int num, Matrix& mat);/*函数名称:替换矩阵中列标为 index中的列，num代表index的大小, mat是需要替换的矩阵*index:矩阵中的列标的一维数组num:index动态数组长度mat:需要替换的矩阵*/Matrix& ReplaceCol(int* index, int num, Matrix& mat);/*函数名称:替换矩阵中列标为 index中的列，num代表index的大小, mat是需要替换的矩阵*index:矩阵中的列标的一维动态数组num:index动态数组长度mat:需要替换的矩阵*/Matrix& ReplaceCol(std::vector index, int num, Matrix& mat);//*****************矩阵初等变化***************///*函数名称:交换矩阵中行标为row0与row1的元素row0:矩阵行标0row1:矩阵行标1*/Matrix& SwapRow(int row0, int row1);/*函数名称:交换矩阵中列标为col0与col1的元素col0:矩阵列标0col1:矩阵列标1*/Matrix& SwapCol(int col0, int col1);/*函数名称:矩阵行加法 rowLocal = rowLocal + rate *rowAddrowLocal:矩阵行标，被加数rowAdd:矩阵行标，加数rate:加数前倍数*/Matrix& AddRow(int rowLocal, int rowAdd, double rate = 1.0);//矩阵加法 某列 + 倍数*某列/*函数名称:矩阵列加法 colLocal = colLocal + rate * colAddcolLocal:矩阵列标，被加数colAdd:矩阵列标，加数rate:加数前倍数*/Matrix& AddCol(int colLocal, int colAdd, double rate = 1.0);//*******************矩阵加法*****************///*函数名称:矩阵加法 本矩阵 = 本矩阵 + mat 前提是两个矩阵维度一致mat:加数矩阵*/Matrix& AddMat(Matrix& mat);//*******************矩阵乘法*****************///*函数名称:矩阵乘法 本矩阵 = 本矩阵*num num:矩阵乘数*/Matrix& MultNum(double num);/*函数名称:矩阵乘法（运算符重载） 本矩阵 = 本矩阵*num num:矩阵乘数*/Matrix& operator * (double num);/*函数名称:矩阵某行乘数值row = row*numnum:矩阵某列乘数row:矩阵行标*/Matrix& MultRow(double num, int row);/*函数名称:矩阵某列乘数值col = col *numnum:矩阵某列乘数col:矩阵列标*/Matrix& MultCol(double num, int col);/*函数名称:矩阵乘法，按照矩阵相乘规则inputMat:乘数矩阵*/Matrix& MultMat(Matrix& inputMat);//******************行列式相关操作***********************///*函数名称:求解矩阵对应行列式数值，前提为方阵，按照定义求解，时间复杂度为O(n!*n)，一般不用此方法求解*/double Det();/*函数名称:求解矩阵对应行列式的顺序主子式，前提为方阵，按照定义求解，时间复杂度为O(n!*n)，一般不用此方法求解order:阶数*/double Det(int order); /*函数名称:矩阵行标为row、列标为col的余子式row:矩阵行标col:矩阵列标*/Matrix& ChildMatrix(int row, int col);/*函数名称:通过高斯列主消元求解矩阵行列式数值，最为常用*/double DetRow();//*********************矩阵求逆********************///*函数名称:矩阵求逆，按照定义求解，1/|A|*(A*)，时间复杂度为O(n!*n)，一般不用此方法*/Matrix& Inverse();/*函数名称:矩阵求逆，通过行初等变化，高斯列主消元法求解*/Matrix& InverseRow();/*函数名称:矩阵求逆，只针对于下三角矩阵进行求解*/Matrix& InverseDownTriangle();/*函数名称:矩阵求逆，只针对于上三角矩阵进行求解*/Matrix& InverseUpTriangle();//矩阵LU分解/*函数名称:矩阵LU分解LMat:矩阵分解后的L矩阵UMat:矩阵分解后的U矩阵*/void ResolveLU(Matrix& LMat, Matrix& UMat);/*函数名称:矩阵的LUP分解 P*A = L*U 添加了列主消元功能LMat:矩阵分解后的L矩阵UMat:矩阵分解后的U矩阵PMat:矩阵分解后的P矩阵*/void ResolveLUP(Matrix& LMat, Matrix& UMat, Matrix& PMat);private:double** m_Matrix;//矩阵int m_Row;//矩阵行数int m_Col;//矩阵列数};#endifMatrix.cpp实现文件：
#include \"Matrix.h\"//******************************构造函数与析构函数********************************//Matrix::Matrix(){}//初始化矩阵 默认值为0Matrix::Matrix(int row, int col){this->m_Row = row;this->m_Col = col;//开辟内存this->m_Matrix = new double* [row];for (int i = 0; i m_Matrix[i] = new double[col] {0.0};}}//初始化矩阵 设定数值Matrix::Matrix(int row, int col, double *mat){this->m_Row = row;this->m_Col = col;//开辟内存this->m_Matrix = new double* [row];for (int i = 0; i m_Matrix[i] = new double[col] {0.0};}//矩阵赋值for(int i = 0; i<row; i++){for (int j = 0; j 
