矩阵类,二维数组

最新推荐文章于 2024-06-12 19:01:34 发布
最新推荐文章于 2024-06-12 19:01:34 发布
阅读量2.2k 收藏 4
点赞数
分类专栏： C++ 文章标签： matrix iostream delete class vector null
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhangcunli/article/details/4725781
版权

      实现一个矩阵类,重载下标操作符, 即 m[i][j],  以及其它运算符

   1:   
   2:  //重载下标操作符, m[i][j], 方法1:
   3:  #pragma once
   4:  #include <iostream>
   5:  #include <cstddef>
   6:  #include <cassert>
   7:   
   8:  template<typename T, std::size_t ROW = 10, std::size_t COLUMN = 10>
   9:  class Matrix
  10:  {
  11:  private:
  12:      std::size_t _ROW;
  13:      std::size_t _COLUMN;
  14:      T* pData;
  15:   
  16:  public:
  17:      Matrix();
  18:      Matrix(std::size_t M, std::size_t N);
  19:      ~Matrix();
  20:   
  21:      //重载下标运算符,实现 a[m][n]
  22:      T* operator[](std::size_t m);
  23:      const T* operator[](std::size_t m) const;
  24:      
  25:      //提供 a(m, n) 这样的操作
  26:      T& operator()(std::size_t m, std::size_t n);
  27:      const T& operator()(std::size_t m, std::size_t n) const;
  28:   
  29:      //拷贝构造
  30:      Matrix(const Matrix<T>& m);
  31:      //重载 =
  32:      Matrix<T>& operator=(const Matrix<T>& m);
  33:   
  34:      //重载 +=
  35:      Matrix<T>& operator+=(const Matrix<T>& m);
  36:   
  37:      //重载 +, -, *
  38:      Matrix<T> operator+(const Matrix<T>& m);
  39:      Matrix<T> operator-(const Matrix<T>& m);
  40:      Matrix<T> operator*(const Matrix<T>& m);
  41:   
  42:      //矩阵转置 !
  43:      Matrix<T> operator!();
  44:   
  45:      //求反 -
  46:      Matrix<T>& operator-();
  47:   
  48:      //显示矩阵
  49:      void displayMatrix() const;
  50:   
  51:      //取得行, 列的大小
  52:      const std::size_t getRow() const;
  53:      const std::size_t getColumn() const;
  54:   
  55:      //注: 重载 << 时, template<typename T1> 必须和 模板类中的类型不一样
  56:      template<typename T1>
  57:      friend std::ostream& operator<<(std::ostream& os, const Matrix<T1>& m);
  58:  };
  59:   
  60:  //默认构造函数
  61:  template<typename T, std::size_t ROW, std::size_t COLUMN>
  62:  Matrix<T, ROW, COLUMN>::Matrix():_ROW(ROW),_COLUMN(COLUMN)
  63:  {
  64:      pData = new T[_ROW*_COLUMN];
  65:      assert(pData);
  66:      memset(pData, 0, _ROW*_COLUMN*sizeof(T));
  67:  }
  68:  //有参构造函数
  69:  template<typename T, std::size_t ROW, std::size_t COLUMN>
  70:  Matrix<T, ROW, COLUMN>::Matrix(std::size_t M, std::size_t N)
  71:                      :_ROW(M), _COLUMN(N)
  72:  {
  73:      pData = new T[_ROW*_COLUMN];
  74:      assert(pData);
  75:      memset(pData, 0, _ROW*_COLUMN*sizeof(T));
  76:  }
  77:   
  78:  //析构函数
  79:  template<typename T, std::size_t ROW, std::size_t COLUMN>
  80:  Matrix<T, ROW, COLUMN>::~Matrix()
  81:  {
  82:      if(pData)
  83:          delete []pData;
  84:      pData = NULL;
  85:  }
  86:  //拷贝构造
  87:  template<typename T, std::size_t ROW, std::size_t COLUMN>
  88:  Matrix<T, ROW, COLUMN>::Matrix(const Matrix<T>& m)
  89:  {
  90:      _ROW = m.getRow();
  91:      _COLUMN = m.getColumn();
  92:      pData = new T[_ROW*_COLUMN];
  93:      assert(pData);
  94:      memcpy(pData, m.pData, _ROW*_COLUMN*sizeof(T));
  95:  }
  96:  //重载下标操作符
  97:  //a[m][n], a[m] 首先调用此重载运算符, 返回指针 (pData + m*_COLUMN)
  98:  //然后进行正常的指针运算 (pData + m*_COLUMN)[n] 
  99:  template<typename T, std::size_t ROW, std::size_t COLUMN>
 100:  T* Matrix<T, ROW, COLUMN>::operator[](std::size_t m)
 101:  {
 102:      assert(m >= 0 && m < _ROW);
 103:      return (pData + m*_COLUMN);
 104:  }
 105:  //for const class
 106:  template<typename T, std::size_t ROW, std::size_t COLUMN>
 107:  const T* Matrix<T, ROW, COLUMN>::operator[](std::size_t m) const
 108:  {
 109:      assert(m >= 0 && m < _ROW);
 110:      return (pData + m*_COLUMN);
 111:      //return operator[](m);
 112:  }//*/
 113:  //a(m,n)
 114:  template<typename T, std::size_t ROW, std::size_t COLUMN>
 115:  T& Matrix<T, ROW, COLUMN>::operator()(std::size_t m, std::size_t n)
 116:  {   
 117:      assert(m < _ROW && m >= 0 && n < _COLUMN && n >= 0);          
 118:      return (pData + m*_COLUMN)[n]; 
 119:  }
 120:  //for const class
 121:  template<typename T, std::size_t ROW, std::size_t COLUMN>
 122:  const T& Matrix<T, ROW, COLUMN>::operator()
 123:          (std::size_t m, std::size_t n) const
 124:  {
 125:      assert(m < _ROW && m >= 0 && n < _COLUMN && n >= 0);          
 126:      return (pData + m*_COLUMN)[n]; 
 127:  }//*/
 128:   
 129:  //查看行列值
 130:  template<typename T, std::size_t ROW, std::size_t COLUMN>
 131:  const std::size_t Matrix<T, ROW, COLUMN>::getRow() const 
 132:  {
 133:      return _ROW;
 134:  }
 135:  template<typename T, std::size_t ROW, std::size_t COLUMN>
 136:  const std::size_t Matrix<T, ROW, COLUMN>::getColumn() const
 137:  {
 138:      return _COLUMN;
 139:  }
 140:   
 141:  //输出整个矩阵
 142:  template<typename T, std::size_t ROW, std::size_t COLUMN>
 143:  void Matrix<T, ROW, COLUMN>::displayMatrix() const
 144:  {
 145:      std::cout << std::endl << "Now The Matrix is: " << std::endl;
 146:      for(std::size_t i = 0; i < _ROW; i++)
 147:          for(std::size_t j = 0; j < _COLUMN; j++)
 148:          {
 149:              std::cout << *(pData+i*_COLUMN+j) << " ";
 150:              if(j == _COLUMN - 1)
 151:                  std::cout << std::endl;
 152:          }
 153:      std::cout << std::endl;
 154:  }
 155:  //重载 =
 156:  template<typename T, std::size_t ROW, std::size_t COLUMN>
 157:  Matrix<T>& Matrix<T, ROW, COLUMN>::operator=(const Matrix<T>& m)
 158:  {
 159:      if(this == &m)
 160:          return *this;
 161:      assert(_ROW == m.getRow() && _COLUMN == m.getColumn());
 162:      for(std::size_t i = 0; i < _ROW; i++)
 163:          for(std::size_t j = 0; j < _COLUMN; j++)
 164:          {
 165:              operator()(i, j) = m(i, j);    
 166:          }
 167:   
 168:      return *this;
 169:  }
 170:  //重载 +=
 171:  template<typename T, std::size_t ROW, std::size_t COLUMN>
 172:  Matrix<T>& Matrix<T, ROW, COLUMN>::operator+=(const Matrix<T>& m)
 173:  {
 174:      assert(_ROW == m.getRow() && _COLUMN == m.getColumn());
 175:      for(std::size_t i = 0; i < _ROW; i++)
 176:          for(std::size_t j = 0; j < _COLUMN; j++)
 177:          {
 178:              operator()(i, j) += m(i, j);    
 179:          }
 180:      return *this;
 181:  }
 182:  //operator+(const Matrix<T>& m)
 183:  template<typename T, std::size_t ROW, std::size_t COLUMN>
 184:  Matrix<T> Matrix<T, ROW, COLUMN>::operator+(const Matrix<T>& m)
 185:  {
 186:      assert(_ROW == m.getRow() && _COLUMN == m.getColumn());
 187:      Matrix<T, ROW, COLUMN> matrix;
 188:      for(std::size_t i = 0; i < _ROW; i++)
 189:          for(std::size_t j = 0; j < _COLUMN; j++)
 190:          {
 191:              matrix(i, j) = operator()(i, j) + m(i, j);    
 192:          }
 193:      return matrix;
 194:  }
 195:  //operator-()
 196:  template<typename T, std::size_t ROW, std::size_t COLUMN>
 197:  Matrix<T>& Matrix<T, ROW, COLUMN>::operator-()
 198:  {
 199:      for(std::size_t i = 0; i < _ROW; i++)
 200:          for(std::size_t j = 0; j < _COLUMN; j++)
 201:          {
 202:              operator()(i, j) =     -operator()(i, j);
 203:          }
 204:      return *this;
 205:  }
 206:  //operator*()
 207:  template<typename T, std::size_t ROW, std::size_t COLUMN>
 208:  Matrix<T> Matrix<T, ROW, COLUMN>::operator*(const Matrix<T>& m)
 209:  {
 210:      assert(_ROW == m.getRow() && _COLUMN == m.getColumn());
 211:      Matrix<T, ROW, COLUMN> matrix;
 212:      for(std::size_t i = 0; i < _ROW; i++)
 213:          for(std::size_t j = 0; j < _COLUMN; j++)
 214:          {
 215:              matrix(i, j) = operator()(i, j) * m(i, j);    
 216:          }
 217:      return matrix;
 218:  }
 219:  //矩阵转置 operator!()
 220:  template<typename T, std::size_t ROW, std::size_t COLUMN>
 221:  Matrix<T> Matrix<T, ROW, COLUMN>::operator!()
 222:  {
 223:      Matrix<T, ROW, COLUMN> matrix;
 224:      for(std::size_t i = 0; i < _ROW; i++)
 225:          for(std::size_t j = 0; j < _COLUMN; j++)
 226:          {
 227:              matrix(i, j) = (*this)(j, i);    
 228:          }
 229:      return matrix;
 230:  }
 231:   
 232:  //for cout << matrix;
 233:  template<typename T1>
 234:  std::ostream& operator<<(std::ostream& os, const Matrix<T1>& m)
 235:  {
 236:      if(m.getRow() <= 0 || m.getColumn() <= 0)
 237:          return os;
 238:      for(std::size_t i = 0; i < m.getRow(); i++)
 239:          for(std::size_t j = 0; j < m.getColumn(); j++)
 240:          {
 241:              os << m(i, j) << " ";
 242:              if(j == m.getColumn() - 1)
 243:                  os << std::endl;
 244:          }
 245:      return os;
 246:  }
 
   1:  //重载下标操作符, m[i][j], 方法2:
   2:  //使用代理类. 定义两个类，当第一个类调用重载的操作符时，使此函数返回
   3:  //第二个类的对象，在第二个类中，同样定义了运算符 [] 重载。但在第一个
   4:  //类中的重载操作符要能访问第二个类的私有成员，那么就应该把第一个类声明
   5:  //为第二个类的友元。
   6:  //----
   7:  //每个MatrixBody对象扮演的是一个一维数组，而这个一维数组没有在使用Matrixs的
   8:  //程序中出现。扮演其它对象的对象通常被称为代理类。在这个例子里，MatrixBody是
   9:  //一个代理类。它的实例扮演的是一个在概念上不存在的一维数组。
  10:  //代理类的概念见: More Effective C++ Item M30：代理类
  11:  #pragma once
  12:  #include <iostream>
  13:  #include <cstddef>
  14:  #include <cassert>
  15:   
  16:  template <typename T> 
  17:  class Matrixs
  18:  {
  19:      class MatrixBody
  20:      {
  21:          friend class Matrixs<T>;
  22:      private:
  23:          T* _pData;
  24:          std::size_t _Rows;
  25:          std::size_t _Column;
  26:          std::size_t _CurrentRow;     //当前行
  27:   
  28:          MatrixBody(std::size_t row, std::size_t column);
  29:   
  30:      public:
  31:          T& operator[](std::size_t j);
  32:          const T& operator[](std::size_t j) const;
  33:          ~MatrixBody();
  34:      }mBody;
  35:   
  36:  public:
  37:      Matrixs(std::size_t row, std::size_t column)
  38:          :mBody(row, column)
  39:      { }
  40:   
  41:   
  42:      //[] 返回第二个类的对象
  43:      MatrixBody& operator[](std::size_t i);
  44:      const MatrixBody& operator[](std::size_t i) const;
  45:   
  46:      //输出矩阵内容
  47:      void displayMatrix() const;
  48:   
  49:  };
  50:   
  51:  //代理类构造函数
  52:  template <typename T> 
  53:  Matrixs<T>::MatrixBody::MatrixBody(std::size_t row, std::size_t column)
  54:  {
  55:      _Rows   = row;
  56:      _Column = column;
  57:      _CurrentRow = -1;
  58:      _pData = new T[_Rows*_Column];
  59:      assert(_pData != NULL);
  60:      memset(_pData, 0, _Rows*_Column*sizeof(T));
  61:  }
  62:  //代理类的下标重载符
  63:  template <typename T> 
  64:  T& Matrixs<T>::MatrixBody::operator[](std::size_t j)
  65:  {
  66:      bool row_error = false;
  67:      bool column_error = false;
  68:      try
  69:      {
  70:          if(_CurrentRow < 0 || _CurrentRow >= _Rows)
  71:              row_error = true;
  72:          if(j < 0 || j >= _Column)
  73:              column_error = true;
  74:          if(row_error || column_error)
  75:              throw 'e';
  76:      }
  77:      catch(char)
  78:      {
  79:          if(row_error)
  80:              cerr << "Row access invalid!" << _CurrentRow << endl;
  81:          if(column_error)
  82:              cerr << "Column access invalid!" << j << endl;
  83:      }
  84:   
  85:      return _pData[_CurrentRow*_Column + j];
  86:  }
  87:   
  88:  //代理类析构函数
  89:  template <typename T> 
  90:  Matrixs<T>::MatrixBody::~MatrixBody()
  91:  {
  92:      if(_pData != NULL)
  93:          delete []_pData;
  94:      _pData = NULL;
  95:  }
  96:   
  97:  //矩阵类下标重载符[] //模板的语法实在是太奇怪了,注意下面必须有 typename
  98:  template<typename T>
  99:  typename Matrixs<T>::MatrixBody& Matrixs<T>::operator[](std::size_t i)
 100:  {
 101:      mBody._CurrentRow = i;
 102:      return mBody;
 103:  }
 104:   
 105:  template <typename T> 
 106:  const typename Matrixs<T>::MatrixBody& Matrixs<T>::operator[](std::size_t i) const
 107:  {
 108:      mBody._CurrentRow = i;
 109:      return mBody;
 110:      //operator[](i);
 111:  }
 112:   
 113:  //输出矩阵内容
 114:  template <typename T> 
 115:  void Matrixs<T>::displayMatrix() const
 116:  {
 117:      std::cout << std::endl << "Now The Matrix is: " << std::endl;
 118:      for(std::size_t i = 0; i < mBody._Rows; i++)
 119:      {
 120:          for(std::size_t j = 0; j < mBody._Column; j++)
 121:          {
 122:              std::cout << *(mBody._pData+i*mBody._Column+j) << " ";
 123:   
 124:              if(j == mBody._Column - 1)
 125:                  std::cout << std::endl;
 126:          }
 127:      }
 128:      std::cout << std::endl;
 129:  }
  
   1:  //test for Matrix class
   2:  #include "MatrixClass.h"
   3:  #include "MatrixClass1.h"
   4:  #include <iostream>
   5:   
   6:  int main()
   7:  {
   8:   
   9:      //指定矩阵大小
  10:      Matrix<int, 6, 5> matrix;
  11:      std::cout << "ROW = " << matrix.getRow() << " "
  12:              << "COLUMN = " << matrix.getColumn() << std::endl;
  13:      matrix.displayMatrix();
  14:      matrix[1][2] = 5;
  15:      std::cout << "matirx[1][2] = " << matrix[1][2] << std::endl;
  16:      matrix[5][4] = 6;
  17:      std::cout << "matirx[5][4] = " << matrix[5][4] << std::endl;
  18:      //matrix[6][4] = 3; //溢出
  19:      matrix.displayMatrix();
  20:      matrix(3, 3) = matrix[5][4];
  21:      matrix.displayMatrix();
  22:   
  23:      //采用默认构造参数，默认大小
  24:      Matrix<int> matrix1;
  25:      matrix.displayMatrix();
  26:      matrix1[3][4] = 5;
  27:      std::cout << "ROW = " << matrix1.getRow() << " "
  28:              << "COLUMN = " << matrix1.getColumn() << std::endl;
  29:      std::cout << "matirx1[3][4] = " << matrix1[3][4] << std::endl;
  30:      std::cout << "matirx1[3][3] = " << matrix1[3][3] << std::endl;
  31:      matrix1.displayMatrix();//*/
  32:   
  33:      //test for +=
  34:      Matrix<int> matrix2;
  35:      matrix2[3][4] = 2;
  36:      matrix2[1][4] = 3;
  37:      matrix2.displayMatrix();
  38:      std::cout << "Test for the operator+=(): ";
  39:      matrix2 += matrix1;     //*/
  40:      matrix2.displayMatrix();
  41:   
  42:      //test for operator-()
  43:      std::cout << "Test for operator-(): ";
  44:      -matrix2;
  45:      matrix2.displayMatrix();
  46:   
  47:      //test for opeartor+() and =
  48:      std::cout << "Test for operator+() and operator=(): ";
  49:      matrix1 = matrix2;
  50:      matrix1 = matrix1 + matrix2;
  51:      matrix1.displayMatrix();
  52:   
  53:      //test for opeartor!()
  54:      std::cout << "Test for operator!(): ";
  55:      matrix2 = !matrix1;
  56:      matrix2.displayMatrix();
  57:   
  58:      std::cout << "Test for cout << matrix : " << std::endl;;
  59:      std::cout << matrix2 << endl;
  60:   
  61:      //测试代理类
  62:      std::cout << "Test for the proxy class: ";
  63:      Matrixs<int> a(5,5);
  64:      a.displayMatrix();
  65:      a[2][1] = 3;
  66:      a.displayMatrix();
  67:   
  68:      return 0;
  69:  }
 

      使用 C++ 实现二维数组, 主要有如下不同的方法,程序中使用的是第一种:

    
    //不同的方法创建一个 m[3][5]
    //1):
    int* m1 = new int[3*5];
    delete []m1;
    //点：调用不够直观
    //优点：连续储存，n 可以不是已知

    //2):
    int (*m2)[5] = new int[3][5];
    delete []m2;
    //缺点：n 必须是已知
    //优点：调用直观，连续储存，程序简洁(经过测试，析构函数能正确调用)

    //3):
    int** m3 = new int*[3];
    for(int i = 0; i < 3; i++)
        m3[i] = new int[5];

    for(int i = 0; i < 3; i++)
        delete []m3[i];
    delete []m3;
    //缺点：非连续储存，程序烦琐，m3 为 A** 类型
    //优点：调用直观，n 可以不是已知

    //4):
    vector< vector<int> > m4;
    m4.resize(3);
    for(int i = 0; i < 5; i++)
        m4.resize(5);
    //缺点：非连续储存，调试不够方便，编译速度下降，程序膨胀(实际速度差别不大)
    //优点：调用直观，自动析构与释放内存，可以调用 stl 相关函数，动态增长
    
    //5):
    vector< vector<int> > m5;
    m5.resize(3*5);
    //方法 1, 4 的结合

    //6):  3) 的改进
    int** m6 = new int*[3];
    m6[0] = new int[3*5];
    for(int i = 1; i < 3; i++)
        m6[i] = m6[i-1] + 5;    
    //优点: 连续存储, n 可以不是已知, 析构方便

 

Yournero9
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
矩阵与二维数组
The_last_knight的博客
11-03 1万+
矩阵运算 矩阵是如何存储的 矩阵在MATLAB是按列的顺序存储的，即先存储第一列，然后是第二列，依次类推。 &amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;gt;&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;gt; A A = 1 2 3 4 5 6 7 8 9 &amp;amp;a
matlab一维矩阵转二维数组,Matlab教程1_矩阵（数组） _ 一维数组的创建
weixin_40008969的博客
03-16 2046
(作者：lcc)Matlab矩阵(数组)的创建按行(row)和列(column)顺序排列的实数或复数的有序集，被称为数组。数组中的任何一个数都被称为这个数组的元素，由其所在的行和列标识，这个标识也称为数组元素的下标或索引。Matlab将标量视为1×1的数组。数组的分类n一维数组，也称为向量(vector) 。Ø 行向量(row vector)、列向量(column vector)。n 二维数组...
python将矩阵转二维数组
m0_46625346的博客
03-21 1192
n = int(input()) tria = [list(map(int,input().split())) for _ in range(n)] print(tria) 谢谢大家的支持，您的一键三连是 罡罡同学前进的最大动力！
矩阵和二维数组
weixin_42121003的博客
01-22 5237
一维数组相当于向量,二维数组相当于矩阵.所以矩阵是数组的子集 数组运算是指数组对应元素之间的运算,也称点运算.矩阵的乘法、乘方和除法有特殊的数学含义，并不是数组对应元素的运算，所以数组乘法、乘方和除法的运算符前特别加了一个点。 矩阵是一个二维数组，所以矩阵的加、减、数乘等运算与数组运算是一致的。但要注意：对于乘法、乘方和除法等三种运算，矩阵运算与数组运算的运算符及含义都不同 例如：对于a,b两个m...
二维数组【数组】
最新发布
2402_82767275的博客
06-12 2315
一维数组，数组的元素都是内置类型的。如果我们，这时候就是⼆维数组。被称为三维数组。统称 为多维数组。
C语言 指针+二维数组详解 （应付期末、考研的最强笔记，建议收藏）
热门推荐
青春无问西东 岁月自成芳华
09-03 4万+
本文通过从二维数组的介绍开始，讲解什么是二维数组——>怎么定义和使用二维数组——>怎么引用二维数组的元素——>怎么通过指针来引用二维数组(具体包括多种分式)来逐步说明指针+二维数组的配合使用，相信学完本文内容，读者对于指针和二维数组会有更加深刻的印象和理解。通过学校期末考试和考研C语言内容完全足够！！！
java任意矩阵以二维数组输入输出
Flora_in_CSDN的博客
02-16 4081
任意矩阵以二维数组输入，以矩阵形式输出 运行示例 输入： [[3,7,8],[9,11,13],[15,16,17],[23,27,28]] 输出： 3 7 8 9 11 13 15 16 17 23 27 28 思路 用字符串参数对输入进行接受并处理，处理步骤如下： （1）用substring()对字符串两头的中括号截掉 （2）用spilt()分别划分每行元素和每行元素中每个数字 （3）将数组由String转变为int方式储存 代码...
python中的二维数组与一维数组，矩阵和一维数组之间的运算
weixin_45699092的博客
03-27 5810
python中的矩阵和数组之间的运算 一、当矩阵为方阵(p×p维) a=np.matrix(np.array([[1,2],[3,4]])) print(a.shape) a 输出： (2, 2) matrix([[1, 2], [3, 4]]) #使用dot b=np.array([1,2]) print(b.shape) b 输出： (2,) array([1, 2]) a.dot(b) 输出： matrix([[ 5, 11]]) #5=1*1+2*2,11=3*1+4*2，
numpy中二维矩阵与一维数组的点乘和乘法
不停学习的巡游者
09-16 5344
第一次写博客，多多关照。 import numpy as np #当二维矩阵为p*p维 #创建2*2的二维矩阵 a_22 = np.array([[1,2],[3,4]]) #(2,2) print("a_22：", a_22) print("a_22的形状：", a_22.shape) print("a_22的维度：", a_22.ndim) #2 print("-"*180) #创建一维数组 b_2 = np.array([1,2]) #(2,) print("b_2：", b_2) prin
二维数组与矩阵算法
qq_70137750的博客
05-19 2318
两个矩阵只有在第一个矩阵的列数（column）和第二个矩阵的行数（row）相同时才有意义。一般单指矩阵乘积时，指的便是一般矩阵乘积。一个m×n的矩阵就是m×n个数排成m行n列的一个数阵。 过程：将第一个矩阵的第i行的每个元素分别乘上第二个矩阵第j列的每个元素然后进项相加，得到的结果就为新矩阵的第i行第j列的元素。 1、首先我们要定义三个二维数组来存储第一个矩阵、第二个矩阵和相乘后得到的新矩阵。 2、对第一个、第二个矩阵的每个进行赋值（要注意的是我们需要让第一个矩阵的列数等于第二个矩阵的行数），然后将..
【二维数组与矩阵乘法】
m0_67691566的博客
05-19 1389
本篇内容主要是用来实现两个二维数组元素相乘，从而得到一个新的矩阵 创建二维数组的结构： // 动态创建 typedef struct TwoDArray{ int rows; int columns; // 一个*表示指向二维数组的列TwoDArry[0]的首地址，两个*表示指向二维数组TwoDarry[0][0]的首地址 int** elements; }TwoDArray,*TwoDArrayPtr; // 静态创建，主要用来后面看一下地址 typedef struct
c#编写的软件，将矩阵(二维数组)渲染成云图&强度图
09-23
c#编写的软件，将矩阵(二维数组)渲染成云图&强度图， 导入二维数据数据即可渲染成非常漂亮的云图，效果非常好，均匀性好，不存在等高线，交叉点，颜色均匀分摊，可以看整体的强度效果， 免费下载，0积分，下载看看...
python矩阵转换为一维数组的实例
09-20
在Python编程语言中，处理矩阵和数组数据时，有时我们需要将二维矩阵转换成一维数组。这在数据处理、科学计算或机器学习等场景中非常常见。本篇将详细讲解如何将Python中的矩阵转换为一维数组，并通过一个具体的实例...
C#实现对二维数组排序的方法
09-03
在C#编程中，二维数组是一种常见的数据结构，用于存储多列或多行的数据。当处理这类数据时，可能需要对数组中的元素进行排序，以便于分析或展示。本篇文章将详细探讨如何在C#中实现对二维数组的排序，特别关注如何...
C#二维数组基本用法实例
01-20
在C#编程语言中，二维数组是一种特殊的数据结构，它允许我们存储多个一维数组，形成类似矩阵的结构。在本实例中，我们将探讨二维数组的基本用法，并通过实例了解如何声明、初始化以及操作这种数据结构。 首先，二维...
Lua中使用二维数组实例
09-21
在这个例子中，`二维数组`是一个3x3的矩阵，其中每个元素通过`二维数组[i][j]`进行访问，例如`二维数组[2][3]`表示第二行第三列的元素。 在实际项目中，我们可能会遇到更复杂的场景。比如在给定的代码片段中，有一...
使用 CL 编译器选项查看 C++ 类内存布局
zhangcunli的专栏
10-23 2859
     今天查资料的时候发现 VS 编译器 CL 的一个编译选项可以查看 C++ 类的内存布局，非常有用。使用如下，从开始程序菜单找到 Visual Stdio 2008/2005 Command Prompt，选择 VS 的命令行工具，按如下格式使用： >cl –d1reportSingleClassLayout[classname]  test.cpp 而使用 –d1reportAllC
Command 命令模式
zhangcunli的专栏
12-06 1362
    Command 命令模式，将一个请求封装为一个对象，从而使你可用不同的请求对客户进行参数化；对请求排除或记录请求日志，以及支持可撤消的操作。也称为动作（Action），事务（Transaction）。     命令模式是通过将请求本身变成一个对象来使工具箱对象可向未指定的应用对象提出请求。这个对象可被存储并像其它对象一样被传递。这一模式的关键是一个抽象的 Command 类，它定义了一个
矩阵和二维数组 运算性能
05-23
矩阵和二维数组的运算性能取决于多个因素，例如数据类型、计算量、硬件配置等等。 一般来说，矩阵运算的性能比二维数组要高。这是因为矩阵运算通常涉及到大量的计算，而矩阵运算可以通过并行计算来提高计算效率。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值