使用2D向量在Matrix类中可变

Question

关闭。 这个问题是题外话。 它当前不接受答案。 了解更多 。

---

想改善这个问题吗？ 更新问题 ，使其成为Stack Overflow 的主题 。

6个月前关闭。

我正在声明一个二维向量，并且我想在Matrix类中为其重载乘法运算符，但是我不知道如何正确地使用set函数填充元素

class Matrix{

    public:
        Matrix();
        Matrix(int,int);
        Matrix(vector<vector<double>>identity);
        void set(int , int , int);
        int get(int , int);
        Matrix operator+(const Matrix &);
        Matrix operator*(const Matrix &);
        Matrix operator-(const Matrix &);
        Matrix operator=(const Matrix &);
       ~Matrix();
    private:
        int row,column;
        std::vector<vector<double>>mat;
};
void Matrix::set(int r,int c ,int e){
   mat[r][c]=e;
}
//overloading * operator
Matrix Matrix::operator*(const Matrix &b)
{
   int result=0;
   for(int i=0 ; i< this->mat.size() ; i++){
       for(int j=0 ; j< this->mat[i].size ; j++){
           for(int k=0 ; k< b.mat[i].size() ; k++){
             result[k]+=(this->mat[i][j]*b.mat[j][k]);
             result.set(i,j,result[k]);
           }
        }
    }
    return result;
}

Answer 1

您想要的内容无法使用operator * ()来完成。 原因是因为成员函数set()将使该类发生突变，即更改对象的成员数组的元素中的值。 operator * ()返回Matrix对象的副本。 它不会修改现有对象。

可以使用operator *= ()来使用set()该operator *= ()旨在修改当前对象。

这是一个如何使用它的示例。 请注意 ，以下示例的编写速度非常快。 只是为了说明不同的运算符重载情况。

#include <iostream>
#include <vector>
#include <algorithm>

template<typename T>
using Array2D = std::vector<std::vector<T> >;

struct Matrix
{
    Array2D<double> m;

    Matrix(std::size_t rows_, std::size_t columns_)
    {
        m.resize(rows_);
        for (auto &&r : m)
        {
            r.resize(columns_);
            std::fill(r.begin(), r.end(),0.0);
        }
    }

    Matrix(Array2D<double> &&m_) : m(std::move(m_))
    {;}

    Matrix(const Matrix &mat_) : m(mat_.m)
    {;}

    void print()
    {
        for (const auto &r : m)
        {
            for (const auto &c : r)
                std::cout<< c <<" ";
            std::cout<<std::endl;
        }
        std::cout<<std::endl;
    }

    void set(std::size_t row_, std::size_t column_, double value_)
    {
        m[row_][column_] += value_;
    }

    Matrix operator * (const Matrix &mat_)
    {
        auto rows = m.size();
        auto cols = m[0].size();
        auto cols2 = mat_.m[0].size();

        Matrix tmp(rows,cols2);
        for(std::size_t r=0; r<rows; ++r)
        {
            for(std::size_t c=0; c<cols2; ++c)
            {
                for(std::size_t k=0; k<cols; ++k)
                {
                    tmp.m[r][c] += this->m[r][k] * mat_.m[k][c];
                }
            }
        }
        return tmp;
    }

    Matrix& operator *= (const Matrix &mat_)
    {
        auto rows = m.size();
        auto cols = m[0].size();
        auto cols2 = mat_.m[0].size();

        Matrix tmp(*this);
        for(std::size_t r=0; r<rows; ++r)
        {
            for(std::size_t c=0; c<cols2; ++c)
            {
                this->m[r][c] = 0.0;
                for(std::size_t k=0; k<cols; ++k)
                {
                    set(r,c, tmp.m[r][k] * mat_.m[k][c]);
                }
            }
        }
        return *this;
    }
};

int main()
{
    Matrix m1 = {{
                    {1,2,0},
                    {0,1,0},
                    {1,2,1}
                }};

    Matrix m2 = {{
                    {0,1,2},
                    {1,2,0},
                    {2,0,0}
                }};

    Matrix m3 = m1*m2;
    m3.print();

    m3 *= m1;
    m3.print();
}

结果是：

2 5 2 
1 2 0 
4 5 2 

4 13 2 
1 4 0 
6 17 2 

在线代码示例： https ： //rextester.com/ZGRI81514