[C++程序] 矩阵类及其常规运算（加、减、乘、转置、求逆、行列式、代数余子式、伴随矩阵）

最新推荐文章于 2024-04-24 22:43:13 发布
最新推荐文章于 2024-04-24 22:43:13 发布
阅读量1.8k 收藏 34
点赞数 4
文章标签： c++ 矩阵
All Rights Reserved © PRE_MITER
本文链接：https://blog.csdn.net/HelloWorld_XH/article/details/111602919
版权

写在前面

本程序中矩阵类的定义为师长给予（两个SetData函数除外），在此不作详细说明。其中涉及的对新旧数据的处理、对函数的封装与保护、对指针的运用及其他理念，由读者自行体会。外框打印只有在极个别情况下才会实现完美对齐，目前还没有找到普适方法。

代码实现

#include <iostream>
#include <iomanip>
#include <cstring>
#include <cmath>
using namespace std;

#define ull unsigned long long

class Matrix
{
	double* pData;
	int rowCount;
	int colCount;

public:
	Matrix(int rows, int cols) :
		pData(nullptr), rowCount(0), colCount(0)
	{
		CreateData(rows, cols);
		ClearData();
	}

	Matrix(int rows, int cols, double value) :
		pData(nullptr), rowCount(0), colCount(0)
	{
		CreateData(rows, cols);
		ClearData(value);
	}

	Matrix(int rows, int cols, const double* initArr, int initArrSize) :
		pData(nullptr), rowCount(0), colCount(0)
	{
		CreateData(rows, cols);
		CopyDataFrom(initArr, initArrSize);
	}

	~Matrix()
	{
		if (pData) delete[]pData;
	}

	Matrix(const Matrix& m) :
		pData(nullptr), rowCount(0), colCount(0)
	{
		CreateData(m.rowCount, m.colCount);
		CopyDataFrom(m.pData, m.rowCount * m.colCount);
	}

	Matrix& operator =(const Matrix& m)
	{
		CreateData(m.rowCount, m.colCount);
		CopyDataFrom(m.pData, m.rowCount * m.colCount);

		return *this;
	}

	double GetData(int rowIndex, int colIndex) const
	{
		return pData[rowIndex * colCount + colIndex];
	}

	double* SetData() const
	{
		return pData;
	}

private:
	void CreateData(int rows, int cols)
	{
		if (rows <= 0) rows = 1;
		if (cols <= 0) cols = 1;

		double* pOldData = nullptr;
		if (pData)
			if (rowCount * colCount != rows * cols)
				pOldData = pData;

		pData = new double[rows * cols];
		this->rowCount = rows;
		this->colCount = cols;
	}

	void CopyDataFrom(const double* newData, int newDataSize, bool clearOther = true)
	{
		double* pTarget = pData;
		const double* pSource = newData;

		double* pTargetEnd1 = pData + rowCount * colCount;
		double* pTargetEnd2 = pData + newDataSize;

		double* pTargetEnd = (pTargetEnd1 < pTargetEnd2) ? pTargetEnd1 : pTargetEnd2;

		while (pTarget < pTargetEnd)
			*(pTarget++) = *(pSource++);

		/*   for (; pTarget < pTargetEnd; ++pTarget, ++pSource)
			   *pTarget = *pSource;

		   for (int i = 0; i < newDataSize && i < rowCount * colCount; ++i)
			   pData[i] = newData[i];*/ //👈上方循环的另外两种写法。

		if (clearOther)
			while (pTarget < pTargetEnd1)
				*pTarget++ = 0;
	}

	void ClearData(double value = 0)
	{
		double* pTarget = pData;
		double* pTargetEnd = pData + rowCount * colCount;

		while (pTarget < pTargetEnd)
			*(pTarget++) = value;
	}

	int GetRowCount() const { return rowCount; }
	int GetColCount() const { return colCount; }
	friend ostream& operator << (ostream& out, const Matrix& m);
	friend int GetRowCount(const Matrix& m);
	friend int GetColCount(const Matrix& m);
	friend double* SetData(Matrix& m, const int rowIndex, const int colIndex);
}; //矩阵类

int GetRowCount(const Matrix& m)
{
	return m.rowCount;
}

int GetColCount(const Matrix& m)
{
	return m.colCount;
}

//返回矩阵指向特定行列的指针
double* SetData(Matrix& m, const int rowIndex, const int colIndex) 
{
	double* p = m.pData;
	p += rowIndex * m.colCount + colIndex;
	return p;
}

//输出流重载（使其能够打印矩阵）👇
ostream& operator << (ostream& out, const Matrix& m) 
{
	int x = 0, y = 0, i = 0; 
	ull blank = 0; ull numsize = 0;
	double temp = 0, edge = 0;

	blank = 9 * (ull)m.colCount - 1;
	out << "┏" << setw(blank) << "┓" << endl;
	for (y = 0; y < m.rowCount; ++y)
	{
		out << "┃";
		
		for (x = 0; x < m.colCount; ++x)
		{
			temp = m.GetData(y, x);  //存储本次要打印的值
			if (temp < 1e-10) temp = 0; //temp过小直接设为0
			edge = fabs(temp - (long)temp); //判断是否为整数

			if (temp != 0 && edge < 1e-4) edge = 0; //不为整数，将edge设为0，将其当作整数
			else if (edge >= 1e-4) edge = 1; //将其当作小数

			numsize = (ull)log10(fabs(temp)) + 1;
			if (temp < 0) numsize += 1;
			if (fabs(temp) < 1) numsize = 0;

			if (numsize == 0 && edge == 1) //处理小于1且带小数的情况。
				out << setprecision(5) << setw(8) << temp;
			else if (numsize == 1)
			{
				if (edge == 1)
					out << setprecision(5) << setw(8) << temp;
				else
					out << setw(5) << temp << setw(3) << "";
			}
			else 
				out << setw(5) << temp << setw(3) << "";

			if (x == m.colCount - 1) out << "┃";
		}
		out << endl;
		out << (y == m.rowCount - 1 ? "┗" : "");
		if (y == m.rowCount - 1) out << setw(blank);
		out << (y == m.rowCount - 1 ? "┛" : "");}
	
	return out;
}

//矩阵转置👇
Matrix operator ~ (const Matrix& m) 
{
	Matrix mT(GetColCount(m), GetRowCount(m));
	double* p = mT.SetData();
	for (int row = 0; row < GetRowCount(mT); ++row)
	{
		for (int col = 0; col < GetColCount(mT); ++col)
			*p++ = m.GetData(col, row);
	}

	return mT;
}

//矩阵乘法👇
Matrix operator * (const Matrix& m1, const Matrix& m2) 
{
	Matrix mX(GetRowCount(m1), GetColCount(m2));
	Matrix ErrormX(1, 1, 0);
	if (GetColCount(m1) != GetRowCount(m2))
	{
		cout << "两矩阵行列不对应，无法相乘。返回错误值:1阶0矩阵。" << endl;
		return ErrormX;
	}

	int t1 = GetColCount(m1), t2 = GetColCount(m2), t3 = GetRowCount(m1);
	int i = 0, x = 0, y = 0;

	double* pTarget = mX.SetData();

	while (x < t3) //t3为m1的行数
	{
		while (y < t2) //t2为m2的列数
		{
			while (i < t1) //t1为m1的列数（也是m2的行数）,对每一个y（即m2的每一列），循环t1次计算出mX当前位置的值，然后y+1
			{
				*pTarget += m1.GetData(x, i) * m2.GetData(i, y);
				i++;
			}
			i = 0; y++; pTarget++;
		}
		y = 0; x++;
	}

	return mX;
}

//矩阵加法👇
Matrix operator + (const Matrix& m1, const Matrix& m2)
{
	Matrix mAdd(GetRowCount(m1), GetColCount(m1));
	Matrix m_Error(1, 1, 0);
	double* p = mAdd.SetData();

	if (GetRowCount(m1) != GetRowCount(m2) ||
		GetColCount(m1) != GetColCount(m2))
	{
		cout << "两矩阵行列不完全相同，无法相加！返回错误值:1阶0矩阵。";
		return m_Error;
	}

	for (int row = 0; row < GetRowCount(m1); row++)
	{
		for (int col = 0; col < GetColCount(m1); col++)
			*p++ = m1.GetData(row, col) + m2.GetData(row, col);
	}

	return mAdd;
}

//矩阵减法
Matrix operator - (const Matrix& m1, const Matrix& m2)
{
	Matrix mMinus(GetRowCount(m1), GetColCount(m1));
	Matrix m_Error(1, 1, 0);
	double* p = mMinus.SetData();

	if (GetRowCount(m1) != GetRowCount(m2) ||
		GetColCount(m1) != GetColCount(m2))
	{
		cout << "两矩阵行列不完全相同，无法相减！返回错误值:1阶0矩阵。";
		return m_Error;
	}

	for (int row = 0; row < GetRowCount(m1); row++)
	{
		for (int col = 0; col < GetColCount(m1); col++)
			*p++ = m1.GetData(row, col) - m2.GetData(row, col);
	}

	return mMinus;
}


//交换函数，用于进行两行交换
inline void swap(Matrix& mdet, int r1, int r2)
{
	int t = GetColCount(mdet);
	for (int i = 0; i < t; i++)
		swap(*SetData(mdet, r1, i), *SetData(mdet, r2, i));
}
//乘积函数，用于对矩阵指定行实行数乘
inline void Matrix_Multiline(Matrix& m, double k, int R)
{
	int C = GetColCount(m);
	for (int i = 0; i < C; i++)
		*SetData(m, R, i) *= k;
}

// 高斯消元求行列式
double fabs(Matrix& m)
{
	Matrix mDen = m;
	int row = GetRowCount(m), col = GetColCount(m);
	if (row != col) //判断是否能求行列式。
	{
		cout << "该矩阵不是方阵，无法求行列式. 返回错误值0." << endl;
		cout << "◢";
		return 0;
	}

	if (row == 2)
		return m.GetData(0, 0) * m.GetData(1, 1) - m.GetData(0, 1) * m.GetData(1, 0);
	
	/*
	参数说明：
	1. k    : 存储最终计算结果。
	2. temp : 当目前循环至t列时，存储t+1行位于主对角线下方的数值。
	3. i,j  : 控制循环需要。
	4. count: 判断首列是否全为0.
	5. t    : 控制循环沿对角线方向下降。
	*/
	double k = 1, temp = 0; int i = 0, j = 0, count = 0, t = 0;

	for (i = 0; i < row; i++)
	{
		if (mDen.GetData(i, 0) == 0)
			count += 1;
	}
	if (count == row) return 0;

	for (t = 0; t < col; t++)//从首列开始，将矩阵变为上三角。沿对角线方向下降，下文将该列主对角线上的元素称为该列首项。
	{
		// 将该列首项变为1. 👇
		if (mDen.GetData(t, t) == 1) {} //若该列首项为1，不做任何事。
		else
		{
			for (i = t; i < row; i++) //从该列首项开始。
			{
				if (mDen.GetData(i, t) == 1) //如果该列i行为1，将其与该列首项所在行对换，跳出行循环
				{
					if (i != t)
					{
						swap(mDen, i, t); //执行对换。
						k = (i == t ? k : -k); //行对换，符号改变。
					}
					goto Deal; //跳转至处理函数。
				}
				else
				{
					if (mDen.GetData(i, t) == 0) //遇到0，进入下一行
						continue;
					else //如果该列i行不为0且不为1，用k存储该行首项的值，并将该行首项变为1，之后将该行与该列首项所在行对换。
					{
						temp = mDen.GetData(i, t); //存储该行首项的值。
						k *= temp; 
						//cout << "k = " << k << endl << endl;
						Matrix_Multiline(mDen, (1 / temp), i); //将该行首项变为1.
						if (i != t)
						{
							swap(mDen, i, t); //交换该行与该列首项所在行。
							k = -k; //改变符号。
						}
						goto Deal; //跳转至处理函数。
					}
				}
			}
			if (t == 0 && count == row) return 0; // 首列全为0，返回0。
		}

	Deal: //将该列除首项外所有元素变为0.👇
		for (i = t + 1; i < row; i++) //从该列首项所在下一行开始。
		{
			temp = mDen.GetData(i, t); //存储该行首项的值。
			if (temp != 0) //如果不为0
			{
				for (j = t; j < col; j++) //从该行主对角线下项开始，每一项都减去将该列首项（即1）所在的行乘上temp。将该行首项变为0.
				{
					//cout << "第" << i + 1 << "行" << j + 1 << "列的元素为" << mDen.GetData(i, j) << endl; 👈调试用语句
					*SetData(mDen, i, j) -= temp * *SetData(mDen, t, j);
					//cout << "第" << i + 1 << "行" << j + 1 << "列的元素为" << mDen.GetData(i, j) << endl; 👈调试用语句
					//cout << "k = " << k << endl; 👈调试用语句
				}
			}
		}
	}

	return k;
}

// 提取余子式对应矩阵
Matrix alogcom(Matrix& m, const int rowIndex, const int colIndex)
{
	int row = GetRowCount(m), col = GetColCount(m);
	int x = 0, y = 0, i = 0, j = 0;
	Matrix mC(row - 1, col - 1);

	for (y = 0; y < row; y++)
	{
		for (x = 0; x < col; x++)
		{
			if (y != rowIndex && x != colIndex)
			{
				*SetData(mC, i, j++) = *SetData(m, y, x);
				if (j == row - 1)
				{
					j = 0; i++;
					break;
				}
			}
		}
	}
	//cout << mC << endl << endl; 👈调试用语句
	return mC;
}
// 计算伴随矩阵
Matrix adjoint(Matrix& m)
{
	int row = GetRowCount(m), col = GetColCount(m);
	short sign = -1;
	Matrix mCom(row, col);
	Matrix mTemp(row, col);
	for (int y = 0; y < row; y++)
	{
		for (int x = 0; x < col; x++)
		{
			mTemp = alogcom(m, x, y);
			//cout << "A" << x + 1 << y + 1 << " = " << fabs(mTemp) << endl; 👈调试用语句
			*SetData(mCom, y, x) = pow(sign, x + y + 2) * fabs(mTemp);
			//cout << mCom << endl; 👈调试用语句
		}
	}

	//cout << mCom << endl; 👈调试用语句
	return mCom;
}
// 求逆矩阵
Matrix operator !(Matrix& m)
{
	int row = GetRowCount(m), col = GetColCount(m);
	Matrix m_(row, col);
	Matrix mCom = adjoint(m);
	Matrix Errorm(1, 1, 0);
	double Den = fabs(m);
	//cout << Den << endl; 👈调试用语句
	if (row != col || Den == 0)
	{
		cout << "该矩阵不可逆。返回错误值:1阶0矩阵。" << endl;
		return Errorm;
	}

	for (int y = 0; y < row; y++)
	{
		for (int x = 0; x < col; x++)
		{
			*SetData(m_, y, x) = mCom.GetData(y, x) / Den;
			//cout << m_ << endl; 👈调试用语句
		}
	}


	return m_;
}

int main()
{
	double arr[15] = { 1, 2, 3, 4, 5, 6, 1, 3, 4, 2, 3, 1, 5, 0.1, -0.5 };
	double arr_[9] = { 1, 0, 0, 0, 1, 0, 0, 0, 1 };
	Matrix m1(3, 3, arr, 9);
	Matrix m2 = ~m1;
	Matrix m3 = m1 * ~m1;
	Matrix m4(3, 3, arr_, 9);
	Matrix m5 = !m1;
	Matrix m6 = m1 * !m1;
	Matrix m7 = adjoint(m1);

	cout << "m1 = " << endl << m1 << endl << endl;
	cout << "m1^T(转置) = " << endl << m2 << endl << endl;
	cout << "m1 * m1^T = " << endl << m3 << endl << endl;
	cout << "m1^*(伴随) = " << endl << m7 << endl << endl;
	cout << "m1 * m1^* = "  << endl << m1 * m7 << endl << endl;
	cout << "|m1|(行列式) = " << fabs(m1) << endl << endl;
	cout << "m1^-1(逆矩阵) = " << endl << m5 << endl << endl;
	cout << "m1 * m1^-1 = " << endl << m6 << endl << endl;
	cout << "m4 = " << endl << m4 << endl << endl;
	cout << "|m4| = " << fabs(m4) << endl << endl;
	cout << "m1 + m4 = " << endl << m1 + m4 << endl << endl;
	cout << "m1 - m4 = " << endl << m1 - m4 << endl << endl;

	system("pause");
	return 0;
}

运行结果

在这里插入图片描述

写在后面

矩阵的其他运算，等高等代数学明白后会补上😥

PRE_MITER
关注
  • 4
    点赞
  • 踩
  • 34
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
【C++ 科学计算】矩阵行列式计算方法
Fanjufei的博客
10-27 1442
矩阵行列式计算方法
C++实现几种基本的矩阵运算
02-17
C++实现几种基本的矩阵运算，包含头文件直接调用
C++实现求解逆矩阵
weymin
04-17 7436
利用C语言求解线性代数中求解逆矩阵的一类问题。 最近在学线代，其中有一个挺烦人的就是求解逆矩阵，虽然求逆矩阵不难，但我自己在解题的时候经常求错，所以就想能不能用算法来求解这一类的题目。 求解逆矩阵一般可以用初等行变换或伴随矩阵方法求解。 这里采用的是伴随矩阵方法。 思路很简单，先求矩阵A对应的行列式|A|，然后在求伴随矩阵即可，伴随矩阵可以用一个二维数组存放即可，注意一下伴随矩阵的元素排列
伴随矩阵介绍及C++实现
网络资源是无限的
05-19 6729
伴随矩阵介绍及C++实现
C++ 矩阵运算
m0_45311187的博客
01-02 1111
C++ 矩阵的各种算法 逆矩阵 高斯 转置矩阵 矩阵运算 矩阵运算大全
Matrix库 通用矩阵运算C++库 功能完整 附带函数功能注释文档
07-09
网络上的Matrix运算库繁多，但有很多功能不够完整，或缺少注释，给使用者带来不少麻烦。该函数库是我搜集到的比较全面的矩阵运算库，而且附带引自清华大学bbs上的函数功能注释，使用方便。 内容包括： Matrix.cpp 执行文件 Matrix.h 头文件 【matrix头文件声明注释】.txt 函数注释说明文件 亲测vs2010下可用 如果涉及到大型稀疏矩阵的运算可以参照我的另一个suitesparse资源
C++矩阵运算（较全面）
love_petrel的博客
07-12 9420
C++矩阵运算，面向对象编程，构建C++矩阵运算库实现包括一维向量、二维矩阵以及三维矩阵的常见操作。
【基础算法】矩阵的几种基本运算 & C++实现
EWEADN
12-04 5867
矩阵是高等代数学中的常见工具，也常见于统计分析等应用数学学科中。物理学中，矩阵于电路学、力学、光学和量子物理中都有应用；计算机科学中，三维动画制作也需要用到矩阵。 矩阵的运算是数值分析领域的重要问题。将矩阵分解为简单矩阵的组合可以在理论和实际应用上简化矩阵的运算。对一些应用广泛而形式特殊的矩阵，例如稀疏矩阵和准对角矩阵，有特定的快速运算算法。
C#实现矩阵运算(包括矩阵的加减乘除转置求逆等)
07-05
C#实现矩阵运算(包括矩阵的加减乘除转置求逆等)
python简单实现矩阵的乘，加，转置和逆运算示例
09-19
主要介绍了python简单实现矩阵的乘，加，转置和逆运算,结合实例形式分析了Python针对矩阵的乘，加，转置和求逆等运算相关实现技巧,需要的朋友可以参考下
C++版多功能矩阵计算器，加减乘除矩阵的秩行列式等
06-10
实现了计算一个矩阵的性质：秩，行列式，迹，矩阵转置，逆矩阵和方阵，最大可支持40行40列。矩阵的行（row）之间必须进行换行，元素间必须用空格隔开。输入计算器的矩阵必须是每个值都为数的矩形矩阵。此外，你可以...
矩阵求逆、加减、乘除、转置等计算程序
05-01
本程序是基于C#语言开发的矩阵计算程序，其中包括了矩阵的求逆运算、加减乘除运算、转置运算等，代码注释详细，算法经典，尤其适合初学者
矩阵运算的加乘转置等
06-18
矩阵运算的加乘转置等，C++语言，Visual Studio 2019编译，
笨蛋学C++【C++基础第六弹】
YSL_Monet的博客
04-24 475
定义类需要用到关键字 class，然后指定类的名称，类的主体是包含在一对花括号中，主体包含类的成员变量和成员函数class 类名{访问修饰符（public/protected/private）:成员变量;成员函数();
理解C语言中的位操作和整数类型：一个温度传感器读取问题的解析
最新发布
qq_61637982的博客
04-24 93
当我们编写嵌入式系统的代码时，我们经常需要使用位操作来处理硬件设备的数据。然而，如果我们对C语言的位操作和整数类型不完全理解，可能会遇到一些难以理解的问题。在这篇博客中，我将通过一个实际的例子来解释这些概念，并提供一个解决方案。
[C++]异常
m0_62327743的博客
04-19 362
[C++]异常
C语言：贪吃蛇游戏（万字解读超详细）
2301_80655639的博客
04-20 935
贪吃蛇这个游戏应该我们小时候都玩过吧我相信能够点进这个博客的应该都很熟悉这个游戏了如果对这个游戏不熟悉的可以网上查查怎么玩，这样才能对这个游戏有个清晰的认知该篇博客需要拥有C语言基础（对指针熟悉、会链表的使用）下面我们需要先学习一些C语言之外的东西认真坚持看完，我相信你一定能完成这个接近500行的C语言贪吃蛇项目该类型内部封装了两个成员，一个x，一个y，代表坐标我们可以将我们的控制台理解为一个平面坐标图横向正方向是x轴正方向，竖向负方向是y轴正方向。
Sylar C++高性能服务器学习记录05 【线程模块-知识储备篇】
拾肆@的博客
04-24 370
Sylar C++高性能服务器学习记录05 【线程模块-知识储备篇】
CSAPP | Lab2-Bomb Lab详细解析
wangs29的博客
04-24 662
邪恶的邪恶博士在我们班的机器上安放了大量的“二元炸弹”。二进制炸弹是一个由一系列阶段组成的程序。每个阶段都要求你在 stdin 上键入一个特定的字符串。如果你键入了正确的字符串，那么这个阶段就会被拆除，炸弹就会进入下一个阶段。否则，炸弹会通过打印“ BOOM 然后终止。当每个阶段都被拆除时，炸弹就会被拆除。我们要处理的炸弹太多了，所以我们给每个学生一个炸弹去拆除。你们的任务，你们别无选择，只能接受，就是在due date前拆除炸弹。祝你好运，欢迎加入拆弹小组！
行列式乘其伴随阵为什么等于行列式的模乘单位矩阵
05-29
我们知道，一个n阶方阵A的伴随阵记作adj(A)，其定义为A的代数余子式组成的矩阵的转置矩阵。即 adj(A) = (A_ij)^(T) 其中A_ij是A的第i行第j列的代数余子式。而A的行列式记作det(A)。 那么，根据行列式的性质，有...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值