devbox
Cpp五条
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

C++实现矩阵类(附代码和功能）_c++矩阵

作者：Cpp五条 | 2024-06-17 18:44:43

赞

踩

c++矩阵

       阅读这篇文章需要掌握C++类的知识以及线性代数的知识，如果有疑问，可在文章下方评论，作者会尽快回复；本文是在作者阅读了平冈和幸的程序员的数学3：线性代数之后而写，在代码设计上借鉴了书中的方法。

       希望这些代码能够帮助你更好地理解线性代数里提到的矩阵运算，笔者所写的矩阵运算代码，都是初学C++时实现的，并不具有工程应用的价值；真诚的希望读者能够使用更好的矩阵运算库，比如Eigen,OpenCV等，笔者对这两个C++库的理解也是比较深入的；当然，如果读者还了解Python的话，笔者建议学习numpy，numpy的Cpp代码可以在Github上搜索NumCpp。

        初写这份代码时，笔者才刚入C++，如今笔者将在github上上传新的矩阵运算代码NANAhttps://github.com/YuruTu/NANA 

相关文档见地址NANA doxygen生成文档https://yurutu.github.io/NANA/files.html

        具体实现的矩阵功能有: 

 

        最初版代码及其使用        

利用C++的类实现矩阵的运算,可实现矩阵的+-*运算，以及用高斯消去法求解线性方程组Ax=b

2018/10/13新增功能 矩阵的行列变换 高斯消元法得到上三角矩阵 

2018/12/9实现矩阵的逆运算等

预编译头文件

pch.h

  1. #ifndef PCH_H
  2. #define PCH_H
  3. #include <cmath>
  4. #include <iostream>
  5. #include <stdlib.h>
  6. #include <cmath>
  7. // TODO: 添加要在此处预编译的标头
  8.  
  9. #endif //PCH_H

 头文件.h

  1. /*
  2. author: cclplus
  3. date:2018/12/09
  4. if you think it is necessary to reward me,
  5. my alipay account number is 707101557@qq.com
  6. */
  7.  
  8. #ifndef __MATRIX_CLL_H__
  9. #define __MATRIX_CCL_H__
  10. #include "pch.h"
  11.  
  12. class Matrix {
  13. private:
  14. 	int rows_num, cols_num;
  15. 	double **p;
  16. 	void initialize();//初始化矩阵
  17.  
  18. public:
  19. 	Matrix(int, int);
  20. 	Matrix(int, int, double);//预配分空间
  21. 	virtual ~Matrix();//析构函数应当是虚函数，除非此类不用做基类
  22. 	Matrix& operator=(const Matrix&);//矩阵的复制
  23. 	Matrix& operator=(double *);//将数组的值传给矩阵
  24. 	Matrix& operator+=(const Matrix&);//矩阵的+=操作
  25. 	Matrix& operator-=(const Matrix&);//-=
  26. 	Matrix& operator*=(const Matrix&);//*=
  27. 	Matrix operator*(const Matrix & m)const;
  28. 	static Matrix Solve(const Matrix&, const Matrix&);//求解线性方程组Ax=b
  29. 	void Show() const;//矩阵显示
  30. 	void swapRows(int, int);
  31. 	double det();//求矩阵的行列式
  32. 	double Point(int i, int j) const;
  33. 	static Matrix inv(Matrix);//求矩阵的逆矩阵
  34. 	static Matrix eye(int );//制造一个单位矩阵
  35. 	int row() const;
  36. 	int col() const;
  37. 	static Matrix T(const Matrix & m);//矩阵转置的实现,且不改变矩阵
  38. 	Matrix gaussianEliminate();//高斯消元法
  39. 	friend std::istream& operator>>(std::istream&, Matrix&);//实现矩阵的输入
  40. };
  41.  
  42.  
  43. #endif

头文件.cpp

  1. /*
  2. author: cclplus
  3. date : 2018 / 12 / 09
  4. if you think it is necessary to reward me,
  5. my alipay account number is 707101557@qq.com
  6. */
  7. #include "pch.h"
  8. #include "matrix.h"
  9. using std::endl;
  10. using std::cout;
  11. using std::istream;
  12. const double EPS = 1e-10;
  13. void Matrix::initialize() {//初始化矩阵大小
  14. 	p = new double*[rows_num];//分配rows_num个指针
  15. 	for (int i = 0; i < rows_num; ++i) {
  16. 		p[i] = new double[cols_num];//为p[i]进行动态内存分配，大小为cols
  17. 	}
  18. }
  19. //声明一个全0矩阵
  20. Matrix::Matrix(int rows, int cols)
  21. {
  22. 	rows_num = rows;
  23. 	cols_num = cols;
  24. 	initialize();
  25. 	for (int i = 0; i < rows_num; i++) {
  26. 		for (int j = 0; j < cols_num; j++) {
  27. 			p[i][j] = 0;
  28. 		}
  29. 	}
  30. }
  31. //声明一个值全部为value的矩阵
  32. Matrix::Matrix(int rows, int cols, double value)
  33. {
  34. 	rows_num = rows;
  35. 	cols_num = cols;
  36. 	initialize();
  37. 	for (int i = 0; i < rows_num; i++) {
  38. 		for (int j = 0; j < cols_num; j++) {
  39. 			p[i][j] = value;
  40. 		}
  41. 	}
  42. }
  43.  
  44. //析构函数
  45. Matrix::~Matrix() {
  46.  for (int i = 0; i < rows_num; ++i) {
  47. 			delete[] p[i];
  48. 		}
  49. 		delete[] p;
  50. }
  51. //实现矩阵的复制
  52. Matrix& Matrix::operator=(const Matrix& m)
  53. {
  54. 	if (this == &m) {
  55. 		return *this;
  56. 	}
  57.  
  58. 	if (rows_num != m.rows_num || cols_num != m.cols_num) {
  59. 		for (int i = 0; i < rows_num; ++i) {
  60. 			delete[] p[i];
  61. 		}
  62. 		delete[] p;
  63.  
  64. 		rows_num = m.rows_num;
  65. 		cols_num = m.cols_num;
  66. 		initialize();
  67. 	}
  68.  
  69. 	for (int i = 0; i < rows_num; i++) {
  70. 		for (int j = 0; j < cols_num; j++) {
  71. 			p[i][j] = m.p[i][j];
  72. 		}
  73. 	}
  74. 	return *this;
  75. }
  76. //将数组的值传递给矩阵(要求矩阵的大小已经被声明过了)
  77. Matrix& Matrix::operator=(double *a){
  78. 	for(int i=0;i<rows_num;i++){
  79. 		for(int j=0;j<cols_num;j++){
  80. 			p[i][j]= *(a+i*cols_num+j);
  81. 		}
  82. 	}
  83. 	return *this;
  84. }
  85. //+=操作
  86. Matrix& Matrix::operator+=(const Matrix& m)
  87. {
  88. 	for (int i = 0; i < rows_num; i++) {
  89. 		for (int j = 0; j < cols_num; j++) {
  90. 			p[i][j] += m.p[i][j];
  91. 		}
  92. 	}
  93. 	return *this;
  94. }
  95. //实现-=
  96. Matrix& Matrix::operator-=(const Matrix& m)
  97. {
  98. 	for (int i = 0; i < rows_num; i++) {
  99. 		for (int j = 0; j < cols_num; j++) {
  100. 			p[i][j] -= m.p[i][j];
  101. 		}
  102. 	}
  103. 	return *this;
  104. }
  105. //实现*=
  106. Matrix& Matrix::operator*=(const Matrix& m)
  107. {
  108. 	Matrix temp(rows_num, m.cols_num);//若C=AB,则矩阵C的行数等于矩阵A的行数，C的列数等于B的列数。
  109. 	for (int i = 0; i < temp.rows_num; i++) {
  110. 		for (int j = 0; j < temp.cols_num; j++) {
  111. 			for (int k = 0; k < cols_num; k++) {
  112. 				temp.p[i][j] += (p[i][k] * m.p[k][j]);
  113. 			}
  114. 		}
  115. 	}
  116. 	*this = temp;
  117. 	return *this;
  118. }
  119. //实现矩阵的乘法
  120. Matrix Matrix::operator*(const Matrix & m)const{
  121. 	Matrix ba_M(rows_num,m.cols_num,0.0);
  122. 	for(int i=0;i<rows_num;i++){
  123. 		for(int j=0;j<m.cols_num;j++){
  124. 			for(int k=0;k<cols_num;k++){
  125. 				ba_M.p[i][j]+=(p[i][k]*m.p[k][j]);
  126. 			}
  127. 		}
  128. 	}
  129. 	return ba_M;
  130. }
  131.  
  132. //解方程Ax=b
  133. Matrix Matrix::Solve(const Matrix &A, const Matrix &b)
  134. {
  135. 	//高斯消去法实现Ax=b的方程求解
  136. 	for (int i = 0; i < A.rows_num; i++) {
  137. 		if (A.p[i][i] == 0) {
  138.  
  139. 			cout << "请重新输入" << endl;
  140. 		}
  141. 		for (int j = i + 1; j < A.rows_num; j++) {
  142. 			for (int k = i + 1; k < A.cols_num; k++) {
  143. 				A.p[j][k] -= A.p[i][k] * (A.p[j][i] / A.p[i][i]);
  144. 				if (abs(A.p[j][k]) < EPS)
  145. 					A.p[j][k] = 0;
  146. 			}
  147. 			b.p[j][0] -= b.p[i][0] * (A.p[j][i] / A.p[i][i]);
  148. 			if (abs(A.p[j][0]) < EPS)
  149. 				A.p[j][0] = 0;
  150. 			A.p[j][i] = 0;
  151. 		}
  152. 	}
  153.  
  154. 	// 反向代换
  155. 	Matrix x(b.rows_num, 1);
  156. 	x.p[x.rows_num - 1][0] = b.p[x.rows_num - 1][0] / A.p[x.rows_num - 1][x.rows_num - 1];
  157. 	if (abs(x.p[x.rows_num - 1][0]) < EPS)
  158. 		x.p[x.rows_num - 1][0] = 0;
  159. 	for (int i = x.rows_num - 2; i >= 0; i--) {
  160. 		double sum = 0;
  161. 		for (int j = i + 1; j < x.rows_num; j++) {
  162. 			sum += A.p[i][j] * x.p[j][0];
  163. 		}
  164. 		x.p[i][0] = (b.p[i][0] - sum) / A.p[i][i];
  165. 		if (abs(x.p[i][0]) < EPS)
  166. 			x.p[i][0] = 0;
  167. 	}
  168.  
  169. 	return x;
  170. }
  171.  
  172. //矩阵显示
  173. void Matrix::Show() const {
  174. 	//cout << rows_num <<" "<<cols_num<< endl;//显示矩阵的行数和列数
  175. 	for (int i = 0; i < rows_num; i++) {
  176. 		for (int j = 0; j < cols_num; j++) {
  177. 			cout << p[i][j] << " ";
  178. 		}
  179. 		cout << endl;
  180. 	}
  181. 	cout << endl;
  182. }
  183. //实现行变换
  184. void Matrix::swapRows(int a, int b)
  185. {
  186. 	a--;
  187. 	b--;
  188. 	double *temp = p[a];
  189. 	p[a] = p[b];
  190. 	p[b] = temp;
  191. }
  192. //计算矩阵行列式的值
  193. double Matrix::det(){
  194. 	//为计算行列式做一个备份
  195. 	double ** back_up;
  196. 	back_up=new double *[rows_num];
  197. 	for(int i=0;i<rows_num;i++){
  198. 		back_up[i]=new double[cols_num];
  199. 	}
  200. 	for(int i=0;i<rows_num;i++){
  201. 		for(int j=0;j<cols_num;j++){
  202. 			back_up[i][j]=p[i][j];
  203. 		}
  204. 	}
  205. 	if(rows_num!=cols_num){
  206. 		std::abort();//只有方阵才能计算行列式，否则调用中断强制停止程序
  207. 	}
  208. 	double ans=1;
  209. 	for(int i=0;i<rows_num;i++){
  210. 		//通过行变化的形式，使得矩阵对角线上的主元素不为0
  211. 		if(abs(p[i][i])<=EPS){
  212. 			bool flag=false;
  213. 			for(int j=0;(j<cols_num)&&(!flag);j++){
  214. 			//若矩阵的一个对角线上的元素接近于0且能够通过行变换使得矩阵对角线上的元素不为0
  215. 				if((abs(p[i][j])>EPS)&&(abs(p[j][i])>EPS)){
  216. 					flag=true;
  217. 					//注：进行互换后,p[i][j]变为p[j][j]，p[j][i]变为p[i][i]
  218. 					//对矩阵进行行变换
  219. 					double temp;
  220. 					for(int k=0;k<cols_num;k++){
  221. 						temp=p[i][k];
  222. 						p[i][k]=p[j][k];
  223. 						p[j][k]=temp;
  224. 					}
  225. 				}
  226. 			}
  227. 		if(flag)
  228. 			return 0;
  229. 		}
  230. 	}
  231. 	for(int i=0;i<rows_num;i++){
  232. 		for(int j=i+1;j<rows_num;j++){
  233. 			for(int k=i+1;k<cols_num;k++){
  234. 				p[j][k]-=p[i][k]*(p[j][i]*p[i][i]);
  235. 			}
  236. 		}
  237. 	}
  238. 	for(int i=0;i<rows_num;i++){
  239. 		ans*=p[i][i];
  240. 	}
  241. 	for(int i=0;i<rows_num;i++){
  242. 		for(int j=0;j<cols_num;j++){
  243. 			p[i][j]=back_up[i][j];
  244. 		}
  245. 	}
  246. 	return ans;
  247. }
  248. //返回矩阵第i行第j列的数
  249. double Matrix::Point(int i, int j) const{
  250. 	return this->p[i][j];
  251. }
  252. //求矩阵的逆矩阵
  253. Matrix Matrix::inv(Matrix A){
  254. 	if(A.rows_num!=A.cols_num){
  255. 		std::cout<<"只有方阵能求逆矩阵"<<std::endl;
  256. 		std::abort();//只有方阵能求逆矩阵
  257. 	}
  258. 	double temp;
  259. 	Matrix A_B=Matrix(A.rows_num,A.cols_num);
  260. 	A_B=A;//为矩阵A做一个备份
  261. 	Matrix B=eye(A.rows_num);
  262. 	//将小于EPS的数全部置0
  263. 	for (int i = 0; i < A.rows_num; i++) {
  264. 		for (int j = 0; j < A.cols_num; j++) {
  265. 			if (abs(A.p[i][j]) <= EPS) {
  266. 				A.p[i][j] = 0;
  267. 			}
  268. 		}
  269. 	}
  270. 	//选择需要互换的两行选主元
  271. 	for(int i=0;i<A.rows_num;i++){
  272. 		if(abs(A.p[i][i])<=EPS){
  273. 			bool flag=false;
  274. 			for(int j=0;(j<A.rows_num)&&(!flag);j++){
  275. 				if((abs(A.p[i][j])>EPS)&&(abs(A.p[j][i])>EPS)){
  276. 					flag=true;
  277. 					for(int k=0;k<A.cols_num;k++){
  278. 						temp=A.p[i][k];
  279. 						A.p[i][k]=A.p[j][k];
  280. 						A.p[j][k]=temp;
  281. 						temp=B.p[i][k];
  282. 						B.p[i][k]=B.p[j][k];
  283. 						B.p[j][k]=temp;
  284. 					}
  285. 				}
  286. 			}
  287. 			if(!flag){
  288. 				std::cout<<"逆矩阵不存在\n";
  289. 				std::abort();
  290. 			}
  291. 		}
  292. 	}
  293. 	//通过初等行变换将A变为上三角矩阵
  294. 	double temp_rate;
  295. 	for(int i=0;i<A.rows_num;i++){
  296. 		for(int j=i+1;j<A.rows_num;j++){
  297. 			temp_rate=A.p[j][i]/A.p[i][i];
  298. 			for(int k=0;k<A.cols_num;k++){
  299. 				A.p[j][k]-=A.p[i][k]*temp_rate;
  300. 				B.p[j][k]-=B.p[i][k]*temp_rate;
  301. 			}
  302. 			A.p[j][i]=0;
  303. 		}
  304. 	}
  305. 	//使对角元素均为1
  306. 	for(int i=0;i<A.rows_num;i++){
  307. 		temp=A.p[i][i];
  308. 		for(int j=0;j<A.cols_num;j++){
  309. 			A.p[i][j]/=temp;
  310. 			B.p[i][j]/=temp;
  311. 		}
  312. 	}
  313. 	//std::cout<<"算法可靠性检测，若可靠，输出上三角矩阵"<<std::endl;
  314. 	//将已经变为上三角矩阵的A，变为单位矩阵
  315. 	for(int i=A.rows_num-1;i>=1;i--){
  316. 		for(int j=i-1;j>=0;j--){
  317. 			temp=A.p[j][i];
  318. 			for(int k=0;k<A.cols_num;k++){
  319. 				A.p[j][k]-=A.p[i][k]*temp;
  320. 				B.p[j][k]-=B.p[i][k]*temp;
  321. 			}
  322. 		}
  323. 	}
  324. 	std::cout<<"算法可靠性检测，若可靠，输出单位矩阵"<<std::endl;
  325. 	for(int i=0;i<A.rows_num;i++){
  326. 		for(int j=0;j<A.cols_num;j++){
  327. 			printf("%7.4lf\t\t",A.p[i][j]);
  328. 		}
  329. 		cout << endl;
  330. 	}
  331. 	A=A_B;//还原A
  332. 	return B;//返回该矩阵的逆矩阵
  333. }
  334. //制造一个单位矩阵
  335. Matrix Matrix::eye(int n){
  336. 	Matrix A(n,n);
  337. 	for(int i=0;i<n;i++){
  338. 		for(int j=0;j<n;j++){
  339. 			if(i==j){
  340. 				A.p[i][j]=1;
  341. 			}else{
  342. 				A.p[i][j]=0;
  343. 			}
  344. 		}
  345. 	}
  346. 	return A;
  347. }
  348. //读取矩阵行列数
  349. int Matrix::row() const{
  350. 	return rows_num;
  351. }
  352. int Matrix::col() const{
  353. 	return cols_num;
  354. }
  355. //实现矩阵的转置
  356. Matrix Matrix::T(const Matrix & m)
  357. {	int col_size=m.col();
  358. 	int row_size=m.row();
  359. 	Matrix mt(col_size, row_size);
  360. 	for (int i = 0; i <row_size; i++) {
  361. 		for (int j = 0; j <col_size; j++) {
  362. 			mt.p[j][i] = m.p[i][j];
  363. 		}
  364. 	}
  365. 	return mt;
  366. }
  367. //高斯消元法
  368. Matrix Matrix::gaussianEliminate()
  369. {
  370. 	Matrix Ab(*this);
  371. 	int rows = Ab.rows_num;
  372. 	int cols = Ab.cols_num;
  373. 	int Acols = cols - 1;
  374.  
  375. 	int i = 0; //跟踪行
  376. 	int j = 0; //跟踪列
  377. 	while (i < rows)
  378. 	{
  379. 		bool flag = false;
  380. 		while (j < Acols && !flag)
  381. 		{
  382. 			if (Ab.p[i][j] != 0) {
  383. 				flag = true;
  384. 			}
  385. 			else {
  386. 				int max_row = i;
  387. 				double max_val = 0;
  388. 				for (int k = i + 1; k < rows; ++k)
  389. 				{
  390. 					double cur_abs = Ab.p[k][j] >= 0 ? Ab.p[k][j] : -1 * Ab.p[k][j];
  391. 					if (cur_abs > max_val)
  392. 					{
  393. 						max_row = k;
  394. 						max_val = cur_abs;
  395. 					}
  396. 				}
  397. 				if (max_row != i) {
  398. 					Ab.swapRows(max_row, i);
  399. 					flag = true;
  400. 				}
  401. 				else {
  402. 					j++;
  403. 				}
  404. 			}
  405. 		}
  406. 		if (flag)
  407. 		{
  408. 			for (int t = i + 1; t < rows; t++) {
  409. 				for (int s = j + 1; s < cols; s++) {
  410. 					Ab.p[t][s] = Ab.p[t][s] - Ab.p[i][s] * (Ab.p[t][j] / Ab.p[i][j]);
  411. 					if (abs(Ab.p[t][s]) <EPS)
  412. 						Ab.p[t][s] = 0;
  413. 				}
  414. 				Ab.p[t][j] = 0;
  415. 			}
  416. 		}
  417. 		i++;
  418. 		j++;
  419. 	}
  420. 	return Ab;
  421. }
  422. //实现矩阵的输入
  423. istream& operator>>(istream& is, Matrix& m)
  424. {
  425. 	for (int i = 0; i < m.rows_num; i++) {
  426. 		for (int j = 0; j < m.cols_num; j++) {
  427. 			is >> m.p[i][j];
  428. 		}
  429. 	}
  430. 	return is;
  431. }
  432.

主程序

  1.  
  2.  
  3. #include "matrix.h"
  4. using namespace std;
  5.  
  6. int main()
  7. {
  8. 	Matrix A = Matrix(3, 3);
  9. 	cin >> A;
  10. 	Matrix b = Matrix(3, 1);
  11. 	cin >> b;
  12. 	Matrix x = Matrix::Solve(A, b);
  13. 	x.Show();
  14. 	return 0;
  15. }
  16.

求赞，求转发

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Cpp五条/article/detail/732348
推荐阅读

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。