从实现 operator[] 的类自动创建迭代器

Automatically create iterator from class that implements operator[]

本文关键字：创建 迭代器 实现 operator      更新时间：2023-10-16

假设我有一个实现operator[]的类，例如：

class Array {
public:
  Array(size_t s) : data(new int[s]) {}
  ~Array() { delete[] data; }
  int& operator[](size_t index) {
    return data[index];
  }
private:
  int* data;
};

有没有办法从类创建随机访问迭代器，而无需手动创建迭代器类及其所有方法？我可以手动定义类，如下所示：

class ArrayIterator : public std::iterator<std::random_access_iterator_tag, int> {
  public:
    ArrayIterator(Array& a) : arr(a), index(0) {}
    reference operator[](difference_type i) {
      return arr[index + i];
    }
    ArrayIterator& operator+=(difference_type i) {
      index += i;
      return *this;
    }
    bool operator==(const ArrayIterator& rhs) {
      return &arr == &rhs.arr && index == rhs.index;
    }
  // More methods here...
  private:
    Array& arr;
    difference_type index;
};

但是这样做很耗时，因为要实现的方法太多了，并且带有 operator[] 的类的每个迭代器都具有完全相同的逻辑。编译器似乎可以自动执行此操作，那么有没有办法避免实现整个迭代器呢？

有没有办法从类创建随机访问迭代器，而无需手动创建迭代器类及其所有方法？

创建随机访问迭代器的最简单方法是仅使用原始指针，它满足RandomAccessIterator概念的所有要求(STL 甚至为原始指针提供了默认的 std::iterator_traits 模板专用化(，例如：

class Array {
public:
    Array(size_t s) : data(new int[s]), dataSize(s) {}
    ~Array() { delete[] data; }
    int& operator[](size_t index) {
        return data[index];
    }
    size_t size() const { return dataSize; } 
    int* begin() { return data; }
    int* end() { return data+dataSize; }
    const int* cbegin() const { return data; }
    const int* cend() const { return data+dataSize; }
private:
    int* data;
    size_t dataSize;
};

使用 operator[] 实现随机访问运算符可能会起作用，但它的效率可能非常低，这就是编译器不会自动执行此操作的原因。想象一下，将operator[]添加到像 std::list 这样的类中，其中"转到元素 i"可能需要最多 i 步骤。根据operator[]递增迭代器将具有复杂度O(n(，其中n是列表的大小。然而，随机访问迭代器的用户期望一定的效率，通常是O(1(。

相关文章：