Question

我想在二维向量的情况下创建一个operator []。搜索之后，我发现传递两个参数是不可能的。我如何获得主要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和非const重载。但这是一般模式对于这样的事情。

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

二维向量中的算子[]

2 个答案: