矩阵乘法模型的问题

Question

在过去的几个小时里，我一直在尝试构建一个 C++ 模块，在请求用户输入 2 个矩阵的大小和内容（仅限于可以相乘的矩阵）时，然后将它们相乘并返回第三个答案矩阵的值。虽然矩阵输入命令似乎基于彻底的测试工作，但我似乎无法从乘法命令中得到正确的答案，尽管了解了算法的每个步骤以及它如何对应于实际的矩阵乘法。答案矩阵的第一个值是正确的，但由于某些因素，所有后续值都是不正确的。有谁知道可能出了什么问题吗？

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

int r, c, a1, a2, b1, b2;  //defines row and column indices
double m[1][1], m2[1][1], a[1][1];   //initializes matrices
double b;
int inflag = true;  
int repflag = false;

void defmatrix() {  //Defines the matrix size of the first inputted matrix
    cout << "Matrix Rows: ";
    cin >> r;
    cout << "Matrix Columns: ";
    cin >> c;
    
}

void fillmatrix() {  //Fills the matrix with automatic or user-inputted values
    if (inflag == true) {
        for (int i = 0; i < r; i++) {
            for (int j = 0; j < c; j++) {
               cout << "Number in row " << i + 1 << " and column " << j + 1 << ": ";
               cin >> b;
               m[i][j] = b;
            }
        }
    } else {
        for (int i = 0; i < r; i++) {
            for (int j = 0; j < c; j++) {
               m[i][j] = 1;
            }
        }
    }
    for (int i = 0; i < r; i++) {
        for (int j = 0; j < c; j++) {
           cout << m[i][j] << "   ";
        }
    }
}

void matrixmult() {  //Multiplication function for matrix math
    if (repflag == false) { 
        cout << "\n" << "Your second matrix will have " << c << " rows" << "\n";
        b1 = c;
        a1 = r;
        r = c; 
        cout << "Second matrix columns: ";
        cin >> c;
        a2 = c;
        double m2[r][c] = {};
        if (inflag == true) {
            for (int i = 0; i < r; i++) {
                for (int j = 0; j < c; j++) {
                    cout << "Number in row " << i + 1 << " and column " << j + 1 << ": ";
                    cin >> b;
                    m2[i][j] = b;
                }
            }
        } else {
            for (int i = 0; i < r; i++) {
                for (int j = 0; j < c; j++) {
                   m2[i][j] = 1;
                }
            }
        }
        a[a1][a2];
        for (int i = 0; i < a1; i++) {
            for (int j = 0; j < a2; j++) {
                b = 0;
                for (int d = 0; d < b1; d++) {
                    b = b + (m[i][d] * m2[d][j]);
                }
                a[i][j] = b;
            }
        }
        for (int i = 0; i < a1; i++) {
            for (int j = 0; j < a2; j++) {
                cout << a[i][j] << "    ";
            }
        }
    } 
}

int main() {  //main file
    defmatrix();
    double m[r][c] = {};
    fillmatrix();
    matrixmult();
}

提前致谢！

Answer 1

几乎每一行都有问题。更容易指出好的部分。计算矩阵乘积的中央 for 循环似乎没问题。大多数其他内容都需要被丢弃并重写。这包括所有声明和所有函数接口。

这是我开始编写程序的方式。

int main()
{
    int rows;
    int cols;
    int common_size; // columns in the matrix A and rows in the matrix B

    std::cout << "Enter number of rows in the result : ";
    std::cin  >> rows;
    std::cout << "Enter number of columns in the result : ";
    std::cin  >> cols;
    std::cout << "Enter the common size : ";
    std::cin  >> common_size;

现在我们需要声明矩阵，但问题来了。人们会天真地想写一些类似的东西

    int a[rows][common_size], b[common_size][cols], c[rows][cols];

，但是可惜，这个不是合法的 C++。该声明可能适用于您的编译器，也可能不适用于您的编译器。有多种方法可以正确声明矩阵。最简单的就是为每个保留固定数量的内存，只使用一部分：

    int a[10][10], b[10][10], c[10][10];

当然你需要检查用户提供的大小不超过10。

另一种方法是使用C++版本的变长数组，称为[向量]。 a 的声明将如下所示：

    std::vector<std::vector<int>> a(rows, std::vector<int>(common_size));

使用第二种方法，对矩阵大小没有真正的限制。

这两种方法都不足以适用于任何真正的软件，但它们足以完成您的 C++ 练习。真正的软件使用更高级的 C++ 概念（例如类）来定义矩阵。只是需要注意一些事情。

我不会继续以同样的详细程度来写它。这是你的任务。我将仅展示 main 的其余部分可能是什么样子。

    input_matrix(a, rows, common_size);
    input_matrix(b, common_size, cols);
    multiply_matrices(a, b, c, rows, common_size, cols);
    print_matrix(c, rows, cols);

注意使用参数的函数调用。实现这些功能，你就可以开始了。请注意，如果您选择向量，则需要通过引用传递一些参数。在这种情况下，您也可以这样编写函数：

    input_matrix(a);
    input_matrix(b);
    c = multiply_matrices(a, b);
    print_matrix(c);

但这是改天再谈的。

Answer 2

尽管您要求在代码中找到错误，但由于您的任务很有趣，但我还是决定为您实现自己的解决方案。即使这是不可接受的答案，它仍然可能对教育目的有用。

我以类矩阵的形式制作了代码，该代码支持两个匹配矩阵（例如a *= b;）之间的乘法操作。与您一样，我还实现了两种方法.input（）和.output（），它们相应地从std :: cin和输出中读取矩阵到std :: Cout。

作为奖励，还有一个方法.at（i，j），它返回带有界限检查矩阵元素的引用，类似于std :: vector。

当然可以将类扩展到许多其他矩阵操作（例如加法a += b;或减法a- = b;），但是我只将我的类限于这些事情您在原始代码中使用的。

要使用我的课程做您想做的事情很简单，因为少数代码行（main（）以下代码段的函数进一步位于代码片段）：

Matrix A, B;
A.Input(); B.Input();
A *= B;
A.Output();

完整代码：

在线尝试！

#include <stdexcept>
#include <vector>
#include <sstream>
#include <iomanip>
#include <iostream>

#define ASSERT_MSG(cond, msg) { if (!(cond)) throw std::runtime_error("Assertion (" #cond ") failed at line " + std::to_string(__LINE__) + "! Msg: '" + std::string(msg) + "'."); }
#define ASSERT(cond) ASSERT_MSG(cond, "")

class Matrix {
public:
    using FloatT = double;
    Matrix(size_t rows = 0, size_t cols = 0)
        : rows_(rows), cols_(cols) {
        Clear();
    }
    Matrix & Clear() {
        m_.clear();
        m_.resize(rows_ * cols_);
        return *this;
    }
    size_t Rows() const { return rows_; }
    size_t Cols() const { return cols_; }
    Matrix & operator = (Matrix && other) {
        rows_ = other.rows_;
        cols_ = other.cols_;
        m_ = std::move(other.m_);
        other.rows_ = 0;
        other.cols_ = 0;
        return *this;
    }
    FloatT & operator() (size_t i, size_t j) {
        return m_[i * cols_ + j];
    }
    FloatT const & operator() (size_t i, size_t j) const {
        return const_cast<Matrix &>(*this)(i, j);
    }
    FloatT & At(size_t i, size_t j) {
        ASSERT_MSG(i < rows_ && j < cols_,
            "Matrix index (" + std::to_string(i) + ", " + std::to_string(j) +
            ") out of bounds (" + std::to_string(rows_) + ", " + std::to_string(cols_) + ")!");
        return (*this)(i, j);
    }
    FloatT const & At(size_t i, size_t j) const {
        return const_cast<Matrix &>(*this).At(i, j);
    }
    Matrix & operator *= (Matrix const & B) {
        Matrix const & A = *this;
        ASSERT_MSG(A.Cols() == B.Rows(),
            "Number of A.Cols " + std::to_string(A.Cols()) +
            " and B.Rows " + std::to_string(B.Rows()) + " don't match!");
        Matrix C(A.Rows(), B.Cols());

        for (size_t i = 0; i < A.Rows(); ++i)
            for (size_t j = 0; j < B.Cols(); ++j) {
                FloatT sum = 0;
                for (size_t k = 0; k < A.Cols(); ++k)
                    sum += A(i, k) * B(k, j);
                C(i, j) = sum;
            }

        *this = std::move(C);
        return *this;
    }
    Matrix & Input() {
        std::cout << "Enter number of rows and columns: ";
        std::cin >> rows_ >> cols_;
        Clear();
        std::cout << "Enter all matrix elements:" << std::endl;
        for (size_t i = 0; i < rows_; ++i)
            for (size_t j = 0; j < cols_; ++j)
                std::cin >> (*this)(i, j);
        return *this;
    }
    Matrix const & Output(size_t precision = 6) const {
        std::vector<std::vector<std::string>> cells(Rows(),
            std::vector<std::string>(Cols()));

        std::ostringstream ss;
        size_t max_len = 0;
        for (size_t i = 0; i < Rows(); ++i)
            for (size_t j = 0; j < Cols(); ++j) {
                ss.str("");
                ss << std::fixed << std::setprecision(precision)
                    << (*this)(i, j);
                cells[i][j] = ss.str();
                max_len = std::max(max_len, cells[i][j].size());
            }

        for (auto const & row: cells) {
            for (auto const & cell: row)
                std::cout << std::string(max_len - cell.size() + 1, ' ')
                    << cell;
            std::cout << std::endl;
        }

        return *this;
    }
private:
    size_t rows_ = 0, cols_ = 0;
    std::vector<FloatT> m_;
};

int main() {
    try {
        Matrix A, B;
        A.Input();
        B.Input();
        A *= B;
        A.Output();
        return 0;
    } catch (std::exception const & ex) {
        std::cout << "Exception: " << ex.what() << std::endl;
        return -1;
    }
}

输入：

Enter number of rows and columns: 3 2
Enter all matrix elements:
1.01 2.02
3.03 4.04
5.05 6.06

Enter number of rows and columns: 2 4
Enter all matrix elements:
 7.07  8.08  9.09 10.10
11.11 12.12 13.13 14.14

输出：输出：

  29.582900  32.643200  35.703500  38.763800
  66.306500  73.447200  80.587900  87.728600
 103.030100 114.251200 125.472300 136.693400