C++ 中内置类型的运算符重载以访问二维数组中的元素

Question

我正在寻找二维数组指针的重载 [] 运算符 访问单元格元素。

二维数组作为int *arr 传递给我的函数。

我们可以通过*(arr+i*N+j) 访问单元格元素，其中N 是列数 i 是行索引，j 是列索引。

但是我们可以这样写arr[i,j] 或arr(i,j) 以获得更好的可读性 使用一些宏或运算符重载？

有什么建议吗？

Answer 1

无法更改构建类型的运算符的行为。如果要重载运算符，则至少有一个操作数必须是用户定义的类型。

Answer 2

没有。

运算符重载需要至少一种参数类型是类/结构/联合。而宏不能做到这一点。

如果可能，您可以获得的最接近的方法是通过引用传递数组。例如：

template<std::size_t width, std::size_t height>
void doThings(int(& array)[width][height])
{
    // access array[i][j];
}

或者，如果这不可能，一个辅助非运算符函数来隐藏丑陋的部分：

int& access(int* array, std::size_t i, std::size_t j)
{
    return *(arr + i*N + j);
}

或者您可能需要解决这里的潜在问题。为什么int*首先传递了一个二维数组？

这里要记住的重要一点是不要使事情过于复杂。

Answer 3

• 您可以编写一个索引函数来隐藏公式。

  如果您的N 是全局定义的，请写

  int index(int i, int j) {
      return i * N + j;
  }
  

  并与它一起使用

  arr[index(i, j)]
  

• 或者，围绕指针编写一个包装类。可以在绝对没有运行时开销的情况下编写此类。它可以有一个运算符来允许语法

  arr[i][j]
  

  其中arr 是包装类的一个实例。这样的包装器可以这样定义：

  class Array2DWrapper {
      int *ptr;
  public:
      Array2DWrapper(int *ptr) : ptr(ptr) {}
  
      int * operator[](int i) {
          return ptr + i*N;
      }
  };
  
  // USAGE:
  void exampleFunction(int *arrPtr) {
      Array2DWrapper arr { arrPtr };
      ...
      arr[i][j];
      ...
  }
  

  如你所见，这个想法是为外部维度重载operator[]，它返回一个指向内部维度的指针。当这个类的用户写arr[i]时，它会调用自定义运算符重载，返回一个int*，然后下一个[j]使用内置的operator[]指针访问元素。

  请注意，上面的类可以用作函数参数，但调用者可以使用指向某个二维数组的原始指针来调用它。这将自动调用此类的构造函数（“隐式转换”）。

  // USAGE with implicit conversion on the call site:
  void exampleFunction(Array2DWrapper arr) {
      ...
      arr[i][j];
      ...
  }
  
  // Note how the caller doesn't need to wrap it explicitly:
  int * myArrPtr = ...;
  exampleFunction(myArrPtr);
  

  如果N 未在全局范围内定义，则应将其作为成员添加到类以及构造函数中。

  class Array2DWrapperDynamicN {
      int *ptr;
      int N;
  public:
      Array2DWrapper(int *ptr, int N) : ptr(ptr), N(N) {}
  
      int * operator[](int i) {
          return ptr + i*N;
      }
  };
  

  但是现在，隐式转换不再起作用了。

  // USAGE:
  void exampleFunction(int *arrPtr, int N) {
      Array2DWrapperDynamicN arr { arrPtr, N };
      ...
      arr[i][j];
      ...
  }
  

Answer 4

你不能直接这样做。
我建议编写一个可以方便地包装二维数组的小类/结构。这里我使用std::vector 而不是int *arr，你不必关心内存管理。以下代码提供了 3 种可能的方法：

方法一（推荐）：通过mat(i,j)访问

operator()(size_t i, size_t j) 被称为函数调用运算符。

template<typename T>
struct Matrix
{
    Matrix(const std::vector<T>& d, size_t s) : Matrix(d, s, s) {}
    Matrix(const std::vector<T>& d, size_t c, size_t r) : data_(d), cols_(c), rows_(r) {}
    std::vector<T> data_;
    size_t    cols_;
    size_t    rows_;
    const T& operator()(size_t i, size_t j) const { return data_[i * cols_ + j]; }
          T& operator()(size_t i, size_t j)       { return data_[i * cols_ + j]; }
    // and you can add other convenient methods
};

像这样使用它：

   Matrix<int> mat({1, 2, 3, 4, 5, 6, 7, 8, 9}, 3, 3); // a 3x3 matrix
   std::cout << mat(1,2) << std::endl;

Live code

如果您在编译时知道大小，那么您可以使用std::array 并相应地更改您的结构：

template<typename T, size_t Cols, size_t Rows> struct Matrix 
{ 
  std::array<T, Cols * Rows> data_; 
  // etc...

方法二：通过mat[{i,j}]访问

使用数组下标运算符只需要一个参数，因此您可以更改/添加以下运算符到您的类：

const T& operator[](const std::array<size_t,2>& a) const { return data_[a[0] * cols_ + a[1]]; }
      T& operator[](const std::array<size_t,2>& a)       { return data_[a[0] * cols_ + a[1]]; }

可以这样调用：

std::cout << mat[{1,2}] << std::endl;

请注意，当您处理多个维度时，此方法很有用（您不必写多个operator()(size_t i, size_t j, size_t k, etc...)

方法3（不推荐）：通过mat[Idx(i),Idx(j)]访问

您可以使用 数组下标运算符 获取 两个参数，但您必须重载逗号运算符，这在两个内置类型之间是不可能的...所以直接访问通过mat[i,j] 是不可能的（感谢leemes 指出这一点的评论）。

但是，您可以创建自己的类型并重载它。这里有一个例子（把它放在你的 Matrix 类定义之前）：

struct Idx 
{
    Idx(size_t ii) : i(ii) {}
    size_t i;
    operator size_t() const { return i; } // implicit user-defined conversion
};

std::array<size_t, 2> operator , (Idx i1, Idx i2)
{
    return { i1, i2 };
}

// etc...
// and we do not have to add Matrix operators since we reused the one from Method 2

像这样使用它：

std::cout << mat[Idx(1),Idx(2)] << std::endl;

这不是那么优雅......

Complete and final live code