C++ 如何为2D数组的包装类重载数组索引运算符？

我直接认为不可能超载

---

我想我必须间接地执行它，但如何实现它？

更简单的解决方案是使用运算符（），因为它允许多个参数

#define ROW 3
#define COL 4

class Matrix
{
   private:
      int mat[ROW][COL];  
    //.....
    //.....

};

int main()
{
  Matrix m;
  int a = m[0][1]; //  reading
  m[0][2] = m[1][1]; // writing
} 

简单的方法是第一个操作符[]返回一个中间对象，第二个操作符[]从数组返回值

class M
{
    public:
       int& operator()(int x,int y)  {return at(x,y);}
    // .. Stuff to hold data and implement at()
};


M   a;
a(1,2) = 4;

---

因为您希望将元素存储在固定大小的数组中，所以这相当容易：

class M
{
    public:
    class R
    {
         private:
             friend class M; // Only M can create these objects.
             R(M& parent,int row): m_parent(parent),m_row(row) {}
         public:
              int& operator[](int col) {return m_parent.at(m_row,col);}
         private:
              M&  m_parent;
              int m_row;
    };

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

    // .. Stuff to hold data and implement at()
};

M   b;
b[1][2] = 3;   // This is shorthand for:

R    row = b[1];
int& val = row[2];
val      = 3;

这应该行得通

---

此外，您可能希望用适当的常量替换

#define

s，或者使用type（int）和size（3x4）的模板参数，使矩阵类更通用。如果要支持动态大小，运算符[]需要返回代理对象。这是可能的，但您可能更喜欢使用带有两个索引参数的运算符（）进行元素访问。

好的优化器是否会将代理版本更改为与

运算符（）

一样高效的代码？这取决于编译器。但我喜欢尽可能直观地使用我的物品。使用对象感觉越自然，出错的可能性就越小。我个人更喜欢代理，但在这种情况下，它是一个半打中的六个，我不能肯定一个比另一个好。是的，我一直使用

operator（）

，但我想这次我会使用代理（我编写游戏引擎），看看它是否会产生任何问题。我无法想象编译器要让它变得同样快会有多困难，因为它将拥有所有运算符的完整定义。应该是：int&operator（）（intx，inty）如此令人印象深刻！我只是为了使用一个模板类（用于矩阵运算）而得到这个。我有一个小的语法错误，因为我试图从R:：operator[]而不是R本身返回R&from。有一次我发现它没问题。非常圆滑！（现在看看是否可以重载“address of”操作符，以便在矩阵中返回向量。：P

#define ROWS 3
#define COLS 4

typedef int row_type[COLS];

class matrix {
   row_type elements[ROWS];
public:
   ...
   row_type const& operator[](int r) const {return elements[r];}
   row_type      & operator[](int r)       {return elements[r];}
   ...
};