C++ 矩阵加法与乘法的实现

最新推荐文章于 2024-05-24 16:04:58 发布
最新推荐文章于 2024-05-24 16:04:58 发布
阅读量1.4w 收藏 20
点赞数 3
文章标签： C++ 数据结构 矩阵
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/code_better/article/details/49662759
版权 
#include <iostream>
using namespace std;

//将矩阵a和b相加得到c
template <class T>
void matrixAdd(T **a, T **b, T **c, int numberOfRows, int numberOfColumns)
{
	for (int i = 0; i < numberOfRows; i++)
		for (int j = 0; j < numberOfColumns; j++)
			c[i][j] = a[i][j] + b[i][j];
}

//两个n*n矩阵的乘法;将矩阵a和b相乘得到c
template <class T>
void squareMatrixMultiply(T **a, T **b, T **c, int n)
{
	for (int i = 0; i < n; i++)
	{
		for (int j = 0; j < n; j++)
		{
			T sum = 0;
			for (int k = 0; k < n; k++)
			{
				sum += a[i][k] * b[k][j];
			}
			c[i][j] = sum;
		}
	}
}

//m*n矩阵与n*p矩阵的乘法
template <class T>
void matrixMultiply(T **a, T **b, T **c, int n,int p)
{
	for (int i = 0; i < m; i++)
	{
		for (int j = 0; j < p; j++)
		{
			for (int k = 0; k < n; k++)
			{
				sum += a[i][k] * b[k][j];
			}
			a[i][j] = sum;
		}
	}
}


int main()
{
	int arr1[3] = { 1, 2, 3 }; //定义一维数组
	int arr2[3] = { 4, 5, 6 };
	int arr3[3] = { 7, 8, 9 };
	int arr4[3] = { 10, 11, 12 };
	int *a[3] = { arr1, arr2, arr3 }; //指针数组
	int *b[3] = { arr1, arr2, arr3 };
	int *c[4] = { arr1, arr2, arr3, arr4 };
	int *result1[3];
	int *result2[3];
	int *result3[4];
	int **f = a;
	matrixAdd(a, b, result1, 3, 3);
	squareMatrixMultiply(a, b, result2, 3);
	matrixMultiply(a, b, result3, 3, 4);
	return 0;

}





                

        

        

    




    

      

        

            

              
                
                  code_better
                
              
            

            

                关注
              
            

        

        

          
    
            
  • 
              
                
                
                
                
                    3
                
              
              
    点赞
    
            
    • 
            
  • 
              
                
                
                
              
              
    踩
    
            
    • 
            
  • 
              
                
                
                
                
                    20
                
              
              
    
                
    
                  
                    收藏
                  
                
    
              
    
              
    
                
    
                  觉得还不错?
                  
                    一键收藏
                  
                 
                
    
              
    
            
    • 
          
  • 
            
    
              
              
            
    
              
              
              
                  5
              
            
            
    评论
    
          
    • 
          
  • 
          
    • 
          
  • 
            
              
            
              
    
            
              
                
            
    
          
    • 
        

      

      










                



	

		

			

				
					
C++中实现矩阵的加法和乘法实例

				
			

			

				

					08-30
				

			

		

		

			
				
本文将详细介绍如何在C++中实现矩阵的加法和乘法。首先，我们需要创建一个名为`Matrix`的类来表示矩阵，并为其定义相关的方法。  1. 构造函数：  - `Matrix()`：默认构造函数，用于创建一个空的矩阵。  - `Matrix...

			
		

	



                

              
                



	

		

			

				
					
C++稀疏矩阵的各种基本运算并实现加法乘法

				
			

			

				

					01-20
				

			

		

		

			
				
代码：  #include  #include #include using namespace std; #define M 4 #define N 4 #define MaxSize 100 typedef int ElemType; typedef struct {  int r;  int c;  ElemType d;///元素值 } TupNode;...

			
		

	



                


  
              

                


	

		

			

				
					
使用c++实现矩阵相加、相乘、转置、求幂

				
			

			

				

					三国小梦的博客
				

				

					04-09
					
					2798
					
				

			

		

		

			
				
引言
对于矩阵我们应该并不陌生吧，在大学线性代数里面每天对它相加，相乘，转置等等，那么在计算机中该怎么实现呢？
首先，先定义一个矩阵的结构体。
const int MAXN = 100; 	//矩阵最大的行和列
// 定义一个矩阵
struct Matrix{
    int row,col; //行，列
    int matrix[MAXN][MAXN];
    Matrix(){}
    Matrix(int r,int c):row(r),col(c){}	// 初始化时同时给行列赋值
};



			
		

	





	

		

			

				
					
C++11标准|用C++写一个矩阵(包含了如何用cmake构建一个工程)

				
			

			

				

					Rolandxxx的博客
				

				

					08-02
					
					4342
					
				

			

		

		

			
				
1.改进版2的矩阵乘法是很慢的，相比matlab差了至少1w倍，我们可以采取以下方式提速，cpu的并行指令，gpu的并行计算，但这些技术都太深入了。因为改进版2的矩阵乘法有三层for循环，版本1的k在最内层，版本2的i在最内层，版本3的j在最内层，用版本3时就可以实现缓存优化，对程序效率有所提高。3.在Matrix的成员函数里重载了()符号，函数名就是operator()，如A是Matrix类的对象，重载后就可以这样用，A.operator()(2,1) = 77等效于A(2, 1) = 77。

			
		

	



		

			
		



	

		

			

				
					
C++ 矩阵乘法

					
最新发布

				
			

			

				

					u011022940的博客
				

				

					05-24
					
					132
					
				

			

		

		

			
				
【代码】C++ 矩阵乘法。

			
		

	





	

		

			

				
					
C++ 矩阵相加（运算符重载）

				
			

			

				

					hhhertzzz的博客
				

				

					05-31
					
					9394
					
				

			

		

		

			
				
题目描述
已知一个矩阵包含行数m、列数n、数值data三个属性，包含初始化、输出、相加等操作，要求
1、在类定义中，矩阵的data属性是一个整数指针型指针。只有创建对象时，根据外来输入的行数和列数，才把指针变成一个二维数组
2、用运算符重载的方法实现两个矩阵对象的相加，矩阵相加是指两个矩阵的每个位置上的两个元素相加
3、用构造函数实现对象的初始化，用输出函数实现矩阵的输出。提示：在构造函数内做输入可以减少很多麻烦
4、在析构函数中释放资源
整数指针变成二位数组的参考代码
//m和n是行数和列数
int m.

			
		

	





	

		

			

				
					
C++ 实现 Matrix （矩阵）类

				
			

			

				

					m0_58880769的博客
				

				

					07-28
					
					8974
					
				

			

		

		

			
				
​c)实现高斯消元法求解线性方程组Matrixx=GaussianElimination(A,b);​b)实现高斯滤波MatrixB=GaussianFilter(A,H)​a)增广矩阵MatrixAb=AugmentMatrix(A,B);​a)零矩阵Matrixzeros(rows,cols);​b)逆矩阵MatrixIA=Inverse(A);​a)默认构造函数，生成一个1,1列的矩阵。......

			
		

	





	

		

			

				
					
c++通过运算符重载实现两个矩阵相加

					
热门推荐

				
			

			

				

					Gardenia
				

				

					01-10
					
					1万+
					
				

			

		

		

			
				
#include "stdafx.h"
#include &lt;iostream&gt;
#include &lt;iomanip&gt;
using namespace std;

//矩阵运算的类
class Matrix
{
private:
	int row;//行
	int col;//列
	int **mat;//指向一级指针变量的二级指针，二级指针变量名可以看做二维数组的数组名
p...

			
		

	





	

		

			

				
					
c++矩阵乘法

				
			

			

				

					05-15
				

			

		

		

			
				
#include  #include  #include  using namespace std;//使用标准名字空间 typedef int Subscript;//凡用到Subscript的地方都定义为int #undef TNT_BOUNDS_CHECK//检查边界是否合法   template <class T>//定义向量类...

			
		

	





	

		

			

				
					
c++实现矩阵运算的加减法乘法以及测试用例

				
			

			

				

					hhl_work的博客
				

				

					07-09
					
					3989
					
				

			

		

		

			
				
最新在看图像AI相关的知识，在此记录一个自己思考的代码用例。
关于矩阵的应用在AI中应用还是很广泛，尤其是深度学习及其特征值提取中。
这里先简单记录上自己简单的基础矩阵算法的类，后续学习中会不断丰富这个类。
参考opencv3.4.0源码中libjasper模块中的jas_seq.c(本例中增加了加减乘运算，缩减和扩充了一些自己的理解)
测试程序结果：

对于矩阵的赋值都采用了调用类创建矩阵时赋值或不赋值(默认参数)处理，具体见代码。
matrix.h 矩阵类的定义
/*******************

			
		

	





	

		

			

				
					
通过类实现矩阵加减法、乘法、转置（C++））

				
			

			

				

					fzy2003的博客
				

				

					03-19
					
					7052
					
				

			

		

		

			
				
定义一个二维方阵类 matrix
通过重载二元运算符“+”、“-”、“*”和一元运算符“~”， 来实现矩阵加、矩阵减、矩阵乘以及矩阵转置。
matrix类的构造、拷贝构造及析构
1.由于矩阵的行与列都是未知的，首先需要通过动态分配内存实现创建任意大小的矩阵，由于类中默认的构造函数无法满足我们的需求，因此首先应该改写构造函数
matrix(int a, int b) {
		r = a;
		c = b;
		mem = new int* [a];
		for (int i = 0; i < a; i+

			
		

	





	

		

			

				
					
使用vc++6.0调用opencv库函数生成5*5单位矩阵

				
			

			

				

					04-18
				

			

		

		

			
				
使用vc++6.0生成调用opencv生成的5*5单位矩阵，从而更好的服务程序！

			
		

	





	

		

			

				
					
矩阵的加法减法乘法，十字链表做的

				
			

			

				

					12-19
				

			

		

		

			
				
矩阵的加法减法乘法，我用的是十字链表。有需要请分享

			
		

	





	

		

			

				
					
用C++二维数组做的两个矩阵相加   没有考虑任何条件

				
			

			

				

					05-10
				

			

		

		

			
				
用C++二维数组做的两个矩阵相加   没有考虑任何条件

			
		

	





	

		

			

				
					
C++实现二位数组加减法

				
			

			

				

					HKaisa的专栏
				

				

					08-12
					
					8260
					
				

			

		

		

			
				
为了深入理解C++中拷贝构造函数、赋值运算符、运算符重载、动态内存分配new，写了一个实现数组加法的类。虽然该程序实现的功能比较简单，但是却包含了不少难点和初学者容易忽视的地方。
//class.h

#include 
#include 
using namespace std;

class matrix{

public:
    const int row,col;
    int **

			
		

	





	

		

			

				
					
矩阵运算（C语言初学者）

				
			

			

				

					weixin_62605148的博客
				

				

					11-26
					
					5927
					
				

			

		

		

			
				
【问题描述】
对于多个N阶矩阵，依次进行加、减运算。

【输入形式】
从标准输入读取输入。第一行只有一个整数N（1≤N≤10），代表矩阵的阶数。
接下来是一个矩阵，是N行，每行有N个整数（可能是正、负整数），是矩阵的所有元素。
然后一行只含一个字符"+"或"-"，代表加、减操作。
然后用同样的方式输入另一个矩阵。
后续仍然是运算符和矩阵。直至运算符为"#"时停止计算，将结果输出。

【输出形式】
向标准输出打印矩阵的操作结果。输出N行，每行对应矩阵在该行上的所有元素，每一行末均输出一个回车符。每个元素占5个

			
		

	





	

		

			

				
					
算法训练 矩阵加法 C++

				
			

			

				

					程序员伤不起
				

				

					01-27
					
					3280
					
				

			

		

		

			
				
思路：逻辑思路不难，就是输入两个矩阵，求它们的和并将它们输出！！如果没有将题目看清楚可能提交n次都报错！！结果一看给的测试数据：就给一个，还有点大！！ 这时最好的方法就是再仔细将题目读一遍！！记住：每行后面不能有多余的空格！

好了，不多说了！上代码：
#include
#include
#include
#include
#include
#include
using namespace std

			
		

	





	

		

			

				
					
一个C++矩阵类的实现

				
			

			

				

					IT- 研究者
				

				

					10-20
					
					1554
					
				

			

		

		

			
				
#ifndef _MATRIX_H_

#define _MATRIX_H_

#include 

using std::vector;




/*类功能：矩阵类

 *原理：采用数组的数组来实现

*/

template

class SeqMatrix

{

public:

explicit SeqMatrix(size_t row=

			
		

	





	

		

			

				
					
strassen矩阵乘法分治法C++代码实现

				
			

			

				

					05-02
				

			

		

		

			
				
以下是一个简单的 Strassen 矩阵乘法的分治法的 C 代码实现：

```c
#include <stdio.h>
#include <stdlib.h>

// 普通矩阵乘法
void matmul(int **a, int **b, int **c, int n) {
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            c[i][j] = 0;
            for (int k = 0; k < n; k++) {
                c[i][j] += a[i][k] * b[k][j];
            }
        }
    }
}

// 矩阵加法
void matadd(int **a, int **b, int **c, int n) {
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            c[i][j] = a[i][j] + b[i][j];
        }
    }
}

// 矩阵减法
void matsub(int **a, int **b, int **c, int n) {
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            c[i][j] = a[i][j] - b[i][j];
        }
    }
}

// Strassen 矩阵乘法
void strassen(int **a, int **b, int **c, int n) {
    // 当矩阵大小小于等于 64 时，使用普通矩阵乘法
    if (n <= 64) {
        matmul(a, b, c, n);
        return;
    }

    // 分割矩阵
    int m = n / 2;
    int **a11 = (int **) malloc(m * sizeof(int *));
    int **a12 = (int **) malloc(m * sizeof(int *));
    int **a21 = (int **) malloc(m * sizeof(int *));
    int **a22 = (int **) malloc(m * sizeof(int *));
    int **b11 = (int **) malloc(m * sizeof(int *));
    int **b12 = (int **) malloc(m * sizeof(int *));
    int **b21 = (int **) malloc(m * sizeof(int *));
    int **b22 = (int **) malloc(m * sizeof(int *));
    int **c11 = (int **) malloc(m * sizeof(int *));
    int **c12 = (int **) malloc(m * sizeof(int *));
    int **c21 = (int **) malloc(m * sizeof(int *));
    int **c22 = (int **) malloc(m * sizeof(int *));
    for (int i = 0; i < m; i++) {
        a11[i] = (int *) malloc(m * sizeof(int));
        a12[i] = (int *) malloc(m * sizeof(int));
        a21[i] = (int *) malloc(m * sizeof(int));
        a22[i] = (int *) malloc(m * sizeof(int));
        b11[i] = (int *) malloc(m * sizeof(int));
        b12[i] = (int *) malloc(m * sizeof(int));
        b21[i] = (int *) malloc(m * sizeof(int));
        b22[i] = (int *) malloc(m * sizeof(int));
        c11[i] = (int *) malloc(m * sizeof(int));
        c12[i] = (int *) malloc(m * sizeof(int));
        c21[i] = (int *) malloc(m * sizeof(int));
        c22[i] = (int *) malloc(m * sizeof(int));
    }
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < m; j++) {
            a11[i][j] = a[i][j];
            a12[i][j] = a[i][j + m];
            a21[i][j] = a[i + m][j];
            a22[i][j] = a[i + m][j + m];
            b11[i][j] = b[i][j];
            b12[i][j] = b[i][j + m];
            b21[i][j] = b[i + m][j];
            b22[i][j] = b[i + m][j + m];
        }
    }

    // 临时矩阵
    int **p1 = (int **) malloc(m * sizeof(int *));
    int **p2 = (int **) malloc(m * sizeof(int *));
    int **p3 = (int **) malloc(m * sizeof(int *));
    int **p4 = (int **) malloc(m * sizeof(int *));
    int **p5 = (int **) malloc(m * sizeof(int *));
    int **p6 = (int **) malloc(m * sizeof(int *));
    int **p7 = (int **) malloc(m * sizeof(int *));
    for (int i = 0; i < m; i++) {
        p1[i] = (int *) malloc(m * sizeof(int));
        p2[i] = (int *) malloc(m * sizeof(int));
        p3[i] = (int *) malloc(m * sizeof(int));
        p4[i] = (int *) malloc(m * sizeof(int));
        p5[i] = (int *) malloc(m * sizeof(int));
        p6[i] = (int *) malloc(m * sizeof(int));
        p7[i] = (int *) malloc(m * sizeof(int));
    }

    // 计算七个子问题
    matsub(b12, b22, p1, m); // p1 = b12 - b22
    strassen(a11, p1, p2, m); // p2 = a11 x p1
    matadd(a11, a12, p1, m); // p1 = a11 + a12
    strassen(p1, b22, p3, m); // p3 = p1 x b22
    matadd(a21, a22, p1, m); // p1 = a21 + a22
    strassen(p1, b11, p4, m); // p4 = p1 x b11
    matsub(b21, b11, p1, m); // p1 = b21 - b11
    strassen(a22, p1, p5, m); // p5 = a22 x p1
    matadd(a11, a22, p1, m); // p1 = a11 + a22
    matadd(b11, b22, p2, m); // p2 = b11 + b22
    strassen(p1, p2, p6, m); // p6 = p1 x p2
    matadd(p4, p5, p1, m); // p1 = p4 + p5
    matadd(p1, p6, p2, m); // p2 = p1 + p6
    matsub(p2, p3, c11, m); // c11 = p2 - p3
    matadd(p4, p1, c12, m); // c12 = p4 + p1
    matadd(p5, p3, c21, m); // c21 = p5 + p3
    matsub(p6, p2, c22, m); // c22 = p6 - p2

    // 合并结果
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < m; j++) {
            c[i][j] = c11[i][j];
            c[i][j + m] = c12[i][j];
            c[i + m][j] = c21[i][j];
            c[i + m][j + m] = c22[i][j];
        }
    }

    // 释放内存
    for (int i = 0; i < m; i++) {
        free(a11[i]);
        free(a12[i]);
        free(a21[i]);
        free(a22[i]);
        free(b11[i]);
        free(b12[i]);
        free(b21[i]);
        free(b22[i]);
        free(c11[i]);
        free(c12[i]);
        free(c21[i]);
        free(c22[i]);
        free(p1[i]);
        free(p2[i]);
        free(p3[i]);
        free(p4[i]);
        free(p5[i]);
        free(p6[i]);
        free(p7[i]);
    }
    free(a11);
    free(a12);
    free(a21);
    free(a22);
    free(b11);
    free(b12);
    free(b21);
    free(b22);
    free(c11);
    free(c12);
    free(c21);
    free(c22);
    free(p1);
    free(p2);
    free(p3);
    free(p4);
    free(p5);
    free(p6);
    free(p7);
}

int main() {
    int n = 8;
    int **a = (int **) malloc(n * sizeof(int *));
    int **b = (int **) malloc(n * sizeof(int *));
    int **c = (int **) malloc(n * sizeof(int *));
    for (int i = 0; i < n; i++) {
        a[i] = (int *) malloc(n * sizeof(int));
        b[i] = (int *) malloc(n * sizeof(int));
        c[i] = (int *) malloc(n * sizeof(int));
    }
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            a[i][j] = rand() % 10;
            b[i][j] = rand() % 10;
            c[i][j] = 0;
        }
    }

    strassen(a, b, c, n);

    printf("Matrix A:\n");
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            printf("%d ", a[i][j]);
        }
        printf("\n");
    }
    printf("\n");

    printf("Matrix B:\n");
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            printf("%d ", b[i][j]);
        }
        printf("\n");
    }
    printf("\n");

    printf("Matrix C:\n");
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            printf("%d ", c[i][j]);
        }
        printf("\n");
    }
    printf("\n");

    for (int i = 0; i < n; i++) {
        free(a[i]);
        free(b[i]);
        free(c[i]);
    }
    free(a);
    free(b);
    free(c);

    return 0;
}
```

此代码中，实现了普通矩阵乘法、矩阵加法、矩阵减法和 Strassen 矩阵乘法。在 Strassen 矩阵乘法中，当矩阵大小小于等于 64 时，使用普通矩阵乘法。分割矩阵使用了动态内存分配，临时矩阵的内存同样使用了动态分配，并在最后释放了所有动态分配的内存。

			
		

	



              



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

  

      
    
          
  • 
              
    
                  
                  
              
    
              
    非常没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    一般
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    有帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    非常有帮助
    
          
    • 
      

      

      

          
          提交
      

      

  




          




        



    





    



      

      

        
      

      





	

		
评论 5

	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值