Question

假设我有一个实现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 []的类的每个迭代器都具有完全相同的逻辑。似乎编译器可以自动执行此操作，那么有没有办法避免实现整个迭代器？

Answer 1

有没有办法从类中创建一个随机访问迭代器，而不必手动创建迭代器类及其所有方法？

创建随机访问迭代器的最简单方法是使用原始指针，它满足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;
};

Answer 2

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

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

2 个答案: