C++ 二维向量中的算子[]

我想在二维向量的情况下创建一个操作符[]。搜索之后，我发现不可能传递两个参数。我如何才能在主界面中获得

m_矩阵[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

类MyMatrix
{
公共方法
MyMatrix（）；
~MyMatrix（）；
int运算符[]（int n）；
私有属性
国际货币基金组织；
国际货币基金组织；
std：：向量m_矩阵；
};
int MyMatrix:：运算符[]（int n，int m）//在cpp中
{
如果（n>=0&&m>=0&&n要继续评论，您可以执行以下操作：

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;
};

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

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

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 ); }
};

类矩阵
{
int myRows；
int菌落；
std：：向量myData；
类代理
{
矩阵*myOwner；
int myRow；
公众：
代理（矩阵*所有者，整数行）
：myOwner（所有者）
，myRow（世界其他地区）
{
}
int运算符[]（int列）（&O）
{
返回myOwner->get（myRow，column）；
}
};
公众：
矩阵（整数行，整数列）
：myRows（行）
，菌柱（柱）
，myData（行*列）
{
}
int&get（int行，int列）
{
断言（0
operator[]
只能接受一个参数，句号。您可以使用
operator（）
，或者让
operator[]
返回一个实现自身的代理
operator[]
。您可以使用
operator（）（size\u t，size\u t）
来代替。那么
std:：vector&operator[]（int n）呢
？@juanchopanza为什么？除了犯下标准库中已经存在的反模式之外，这有什么变化呢。@juanchopanza我批评的是使用
size\u t
，而不是
（）
。我在自己的回答中提到了这种可能性。我会非常惊讶
at
是否合适。你真的认为所有客户端都能够从可能的编程错误中恢复过来是合理的吗？@JamesKanze：我认为这比OP的检查更好。但是
断言
会更好。我没有注意到他检查了一下。我同意，那更糟。
assert
是必需的。@Jarod42我试过代码也许我不懂好的'std:：vector&MyMatrix:：operator[]（int m）{return m_matrix[m]；}int&MyMatrix:：operator（）（int m，int n）{return m_matrix[m][n]}“//在cpp中，它不起作用，我做错了什么？@Jarod42谢谢你的回答，但是如果我想获得基本的表达，你能解释一下什么是代理吗？（我是初学者，对不起）@Laura代理正是我展示的；一个替代另一个的类，以提供额外的功能。两个最常用的用法（我认为）是支持多个
[]
，如下所示，以及模拟返回类型的重载。
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 ); }
};