運算子多載矩陣乘法-有解無憂

我遇到的問題是如何為 K 的最內部回圈獲得正確的列數。一個例子是一個 2x3 矩陣和一個 3x2 矩陣相乘。結果應該是一個 2x2 矩陣，但目前我不知道如何將 2 的值發送給運算子多載函式。它應該是 int k = 0; k < 第一個矩陣的列；k

  Matrix::Matrix(int row, int col)
   {
    rows = row;
    cols = col;
    cx = (float**)malloc(rows * sizeof(float*));  //initialize pointer to pointer matrix
   for (int i = 0; i < rows; i  )
      *(cx   i) = (float*)malloc(cols * sizeof(float));
    }



Matrix Matrix::operator * (Matrix dx)
 {
   Matrix mult(rows, cols);
    for (int i = 0; i < rows; i  )
     { 
       for (int j = 0; j < cols; j  )
        {
            mult.cx[i][j] = 0;
           for (int k = 0; k < ?;k  ) //?????????????
            {
                 mult.cx[i][j]  = cx[i][k] * dx.cx[k][j];
            }
        }
    }
      mult.print();
      return mult;


 //calling
  Matrix mult(rowA, colB);
           mult = mat1 * mat2;
}

uj5u.com熱心網友回復：

線性代數規則說結果應該有維度行 x dx.cols

    Matrix Matrix::operator * (Matrix dx)
    {
     Matrix mult(rows, dx.cols);
    for (int i = 0; i < rows; i  )
     { 
       for (int j = 0; j < cols; j  )
        {
            mult.cx[i][j] = 0;
           for (int k = 0; k < cols;k  ) //?????????????
            {
                 mult.cx[i][j]  = cx[i][k] * dx.cx[k][j];
            }
        }
    }
      mult.print();
      return mult;

uj5u.com熱心網友回復：

一些隨機提示：

你的代碼基本上是 C；它不使用（例如）來自 C 的重要記憶體安全特性。（運算子多載是唯一使用的類似 C 的特性。）我建議您多利用 C 。
malloc()在 C 中嚴格避免。使用std::make_unique(...)或者，如果沒有其他方法，使用原始new運算子。（順便說一句，總有另一種方式。）在后一種情況下，請確保有一個帶有deleteor的解構式delete[]。使用的malloc()程式碼中聞起來像記憶體泄漏。
什么能是const 應該是const。在建構式的初始化串列中初始化盡可能多的類成員，并const在適當的時候創建它們。（例如，Matrix尺寸不會改變，應該是const。）
在撰寫類容器類（Matrix某種意義上，a可能是）時，不要將其限制為單一資料型別；你未來的自己會感謝你。（如果你需要一個double而不是一個float怎么辦？它是單行編輯還是通宵搜索被遺忘的float東西會侵蝕你的精確度？）

這是一個顯示矩陣乘法的快速而骯臟的可運行示例：

#include <cstddef>
#include <iomanip>
#include <iostream>
#include <memory>

namespace matrix {
using std::size_t;

template<typename Element>
class Matrix {
  class Accessor {
   public:
    Accessor(const Matrix& mat, size_t m) : data_(&mat.data_[m * mat.n_]) {}
    Element& operator [](size_t n) { return data_[n]; }
    const Element& operator [](size_t n) const { return data_[n]; }

   private:
    Element *const data_;
  };

 public:
  Matrix(size_t m, size_t n) : m_(m), n_(n),
                               data_(std::make_unique<Element[]>(m * n)) {}
  Matrix(Matrix &&rv) : m_(rv.m_), n_(rv.n_), data_(std::move(rv.data_)) {}

  Matrix operator *(const Matrix& right) {
    Matrix result(m_, right.n_);
    for (size_t i = 0; i < m_;   i)
      for (size_t j = 0; j < right.n_;   j) {
        result[i][j] = Element{};
        for (size_t k = 0; k < n_;   k) result[i][j]  =
            (*this)[i][k] * right[k][j];
      }
    return result;
  }

  Accessor operator [](size_t m) { return Accessor(*this, m); }
  const Accessor operator [](size_t m) const { return Accessor(*this, m); }
  size_t m() const { return m_; }
  size_t n() const { return n_; }

 private:
    const size_t m_;
    const size_t n_;
    std::unique_ptr<Element[]> data_;
};

template<typename Element>
std::ostream& operator <<(std::ostream &out, const Matrix<Element> &mat) {
  for (size_t i = 0; i < mat.m();   i) {
    for (size_t j = 0; j < mat.n();   j) out << std::setw(4) << mat[i][j];
    out << std::endl;
  }
  return out;
}
}  // namespace matrix

int main() {
  matrix::Matrix<int> m22{2, 2};
  m22[0][0] = 0;  // TODO: std::initializer_list
  m22[0][1] = 1;
  m22[1][0] = 2;
  m22[1][1] = 3;

  matrix::Matrix<int> m23{2, 3};
  m23[0][0] = 0;  // TODO: std::initializer_list
  m23[0][1] = 1;
  m23[0][2] = 2;
  m23[1][0] = 3;
  m23[1][1] = 4;
  m23[1][2] = 5;

  matrix::Matrix<int> m32{3, 2};
  m32[0][0] = 5;  // TODO: std::initializer_list
  m32[0][1] = 4;
  m32[1][0] = 3;
  m32[1][1] = 2;
  m32[2][0] = 1;
  m32[2][1] = 0;

  std::cout << "Original:\n\n";
  std::cout << m22 << std::endl << m23 << std::endl << m32 << std::endl;

  std::cout << "Multiplied:\n\n";
  std::cout << m22 * m22 << std::endl
            << m22 * m23 << std::endl
            << m32 * m22 << std::endl
            << m23 * m32 << std::endl
            << m32 * m23 << std::endl;
}

可能的改進和其他建議：

添加一致性檢查。throw，例如，一個std::invalid_argumentwhen 維度在乘法上不匹配，即 when m_ != right.n_，以及 a std::range_errorwhen theoperator []獲取越界引數。（檢查可能是可選的，激活（例如）使用if constexpr.進行除錯。）
使用 astd::initializer_list等進行初始化，以便您可以（例如）行內const Matrix初始化。
始終使用valgrind. （提示：與-g讓我們一起valgrind列印錯誤發生的行號（或相關的先前（取消）分配發生的地方）。）
代碼可以通過不使用operator []任何地方并通過指標演算法獲得一些樂趣來使代碼更短更優雅（不一定更有效；編譯器優化現在很神奇）。
Make the type system better, so that (e.g.) Matrix instances with different types can play well with each other. Perhaps a Matrix<int> multiplied by a Matrix<double> could yield a Matrix<double> etc. One could also support multiplication between a scalar value and a Matrix. Or between a Matrix and a std::array, std::vector etc.

轉載請註明出處，本文鏈接：https://www.uj5u.com/ruanti/321241.html

標籤：C 矩阵运算符重载

上一篇：生成字典序大于輸入的字串

下一篇：最大資料包數