二维向量中的运算符 []

Question

我想在二维向量的情况下创建一个运算符[]。经过搜索，我发现不可能传递两个参数。我如何获得m_matrix[i][j] 的主要值？

相关代码：

class MyMatrix  
{
    public:            // Methods

        MyMatrix();
        ~MyMatrix();

        int operator[] (int n);

    private:          // Attributes

        int m_n;
        int m_m;

        std:: vector <std:: vector <int> > m_matrix;

};

int MyMatrix::operator[](int n, int m)  // in the cpp
{
    if (n>=0 && m>=0 && n<=m_n && m<=m_m)
    {
      return m_matrix[n-1][m-1];
    }
    else
    {   cout<<"******************"<<endl;
        cout<<"No valid index"<<endl;
        cout<<"******************"<<endl;
        return 0;
    }
}

...

mat_test1[2][2]; // for example in the main

这是怎么回事？

Answer 1

要恢复评论，您可以：

class MyMatrix
{
public:

    // Other methods

    const std::vector<int>& operator[] (int m) const { return m_matrix.at(m); }
    std::vector<int>& operator[] (int m) { return m_matrix.at(m); }

    int operator () (int m, int n) const { return m_matrix.at(m).at(n); }
    int& operator () (int m, int n) { return m_matrix.at(m).at(n); }

private:
    std::vector<std::vector<int>> m_matrix;
};

注意：我使用 at 而不是 [] 来使用来自向量的检查，因此它会为越界访问抛出异常。

然后使用它：

MyMatrix matrix(5, 4); // size of the matrix from constructor

matrix[0][1] = 42; // MyMatrix::operator [] followed by std::vector<int>::operator[]
matrix(2, 2) = 42; // MyMatrix::operator () (int, int);

Live example.

Answer 2

有几种方法，但最终都归结为使用 代理。

由于各种原因，矩阵的通常实现不是 std::vector<std::vector<T>>，但只是 std::vector<T>，带有 指数的适当计算。在这种情况下：

class Matrix
{
    int myRows;
    int myColumns;
    std::vector<int> myData;

    class Proxy
    {
        Matrix* myOwner;
        int myRow;
    public:
        Proxy( Matrix* owner, int row )
            : myOwner( owner )
            , myRow( row )
        {
        }
        int& operator[]( int column )
        {
            return myOwner->get( myRow, column );
        }
    };
public:
    Matrix( int rows, int columns )
        : myRows( rows )
        , myColumns( columns )
        , myData( rows * columns )
    {
    }

    int& get( int row, int column )
    {
        assert( 0 <= row && row < myRows
                && 0 <= column && column < myColumns );
        return myData[ row * myColumns + column ];
    }

    Proxy operator[]( int row ) { return Proxy( this, row ); }
};

事实上，您需要更多的重载（可能还有两个代理） 处理 const 和非常量重载。但这是一般模式 对于这样的事情。

也请注意，有两个关于此类重载的约定。 一种是说[] 返回一个投影，并且正确 将索引处理成多维结构的解决方案是 重载operator()（可以取任意数量的 参数）。我个人更喜欢[][] 解决方案，但是这个 偏好不是普遍的；很多人更数学 背景更喜欢使用()。