Question

我尝试使用clear函数对随机生成的值进行矩阵乘法。因此，我希望使用函数（mat_def）生成矩阵，并使用另一个函数（mat_mul）在矩阵作为参数发送时将它们相乘。

#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

using namespace std;

double mat_def(int n) //how to return the matrix
{
    double a[n][n];

    double f; 

    for(int i=0; i<n;  i++)
    {
        for(int j=0; j<n; j++)
        {
            f= rand();
            cout<<f ;
            a[i][j]=f;
        }

    }

    return 0;
}


double mat_mul( int n, double a[n][n], double b[n][n]) //how to send matrix as parameter
{
    return 0;
}


int main()
{
    /* initialize random seed: */
    srand (time(NULL));
    mat_def(10); 
}

Answer 1

这是一个很好的标准C ++ Matrix模板。

Matrix.h

#include <vector>

class Matrix
{
    class InnerM
    {
        private:
           int ydim;
           double* values;

        public:
            InnerM(int y) : ydim(y)
            {
                values = new double[y];
            }

            double& operator[](int y)
            {
                return values[y];
            }
    };

    private:
       int xdim;
       int ydim;

       std::vector<InnerM> inner;

    public:

       Matrix(int x, int y) : xdim(x), ydim(y), inner(xdim, InnerM(ydim))
       {
       }

       InnerM& operator[](int x)
       { 
           return inner[x];
       }
};

所有内存泄漏都在那里，但你明白了。从这里开始，您可以通过覆盖Matrix类中的::operator*()来处理乘法。

Answer 2

我假设您的问题是定义二维数组，然后将其传递给mat_mul函数以乘以矩阵。其余的将非常简单。

定义2-D阵列（考虑到运行时的内存需求）：

    int rows,cols;
    cin >> rows;
    cin >> cols;

    int **arr = new int*[rows];          // rows X cols 2D-array 
    for(int i = 0; i < rows; ++i) {
        arr[i] = new int[cols];
    }

您可以使用所需的行和列完全相同地定义另一个二维数组。

现在，将2-D数组传递给函数：

void mat_mul(int **arr1, int **arr2, int m, int n, int p, int q){
    //define a 2-D array to store the result
    //do the multiplication operation
    //you could store the result in one of the two arrays
    //so that you don't have to return it 
    //or else the return type should be modified to return the 2-D array
}

示例：

void display(int **arr, int row, int col){
    for (int i=0; i<row; i++){
        for(int j=0;j<col; j++){
            cout << arr[i][j] << '\t';
        }
        cout << endl;
    }
}

如果不再需要，请使用以下语法删除内存：

for(int i=0; i<rows; i++){
  delete[] array[i];
}
delete[] array;

希望这足以让你的工作完成！

关于如何在SO上返回二维数组已有答案。请查看以下链接。

https://stackoverflow.com/a/8618617/8038009

Answer 3

返回原始分配是一个糟糕的赌注。您需要管理自己分配的所有内存并使用矩阵大小参数传递它。

为什么受苦？使用矩阵类

template<class Type>
class Matrix{
    int rows;
    int cols;
    std::vector<type> data;
public:
    Matrix(int row, int col):rows(row), cols(col), data(rows*cols)
    {
        // does nothing. All of the heavy lifting was in the initializer
    }
    // std::vector eliminates the need for destructor, assignment operators, and copy 
    //and move constructors.
    //add a convenience method for easy access to the vector
    type & operator()(size_t row, size_t col)
    {
        return data[row*cols+col];
    } 
    type operator()(size_t row, size_t col) const
    {
        return data[row*cols+col];
    } 
};

用法是

Matrix<double> mat_mul(const Matrix<double> &a, const Matrix<double> &b) 
{
    Matrix<double> result;
    // do multiplication 

    return result;
}

int main()
{
    /* initialize random seed: */
    srand (time(NULL));
    Matrix<double> matA(10, 10); 
    matA(0,0) = 3.14; // sample assignment
    matA(9,9) = 2.78;
    double x = matA(0,0) * matA(9,9)
    Matrix<double> matB(10, 10); 

    Matrix<double> matC = mat_mul(matA, matB) ;
}

可以在课程中添加更多功能，例如initializer list的构造，以使您的生活更轻松。您还可以为operator *指定Matrix重载，如果您选择，则使用该重载代替mat_mul。有关该选项的更多信息，请阅读Operator overloading。

Matrix - 返回并传递为参数c ++

3 个答案: