迭代器实战——数组分块工具

迭代器简介

c++中经常会用到这样的写法：

std::vector vec; // 假设其中已经有数据
for (auto it = vec.begin(); it != vec.end(); ++it) {
  cout << "value is:" << *it << endl;
}

上面代码中，it即是迭代器，通过迭代器自增可以遍历vector容器，而通过解引用（*）可以访问当前迭代器指向的数据。这样看，迭代器有点类似于数组的指针。

而range-based循环实际上也是依赖迭代器：

for (auto value : vec) {
  // ...
}

这种写法实际上等同于上面的显示使用迭代器。

那么，如何实现自己的迭代器呢？下面通过一个真实的例子一步步实现。

案例描述

假设我们有一个批量接口，每次只能处理100个id。函数签名如下：

void HandleIds(const vector &ids);

现在我们有1万条id需要查询，就要分100次进行查询。那么我们首先要将其分成100组。当然这并不困难，但作为一名优秀的程序员，绝不能容忍每次都这样的重复性工作。于是我们希望做一个足够好用的工具，它可以这样使用：

std::vector all_ids; // 假设其中已经有数据
for (const auto &chunk : ChunkSpliter(all_ids, 100)) {
    HandleIds(chunk); // chunk中包含100个id
}

需求分析

分析一下上述效果，我们发现：

1. ChunkSpliter是一个类，构造函数包含两个参数
2. ChunkSpliter的实例是可迭代对象
3. 对迭代器解引用，可以得到std::vector对象

对于第1点，只需定义一个ChunkSpliter类，并显示声明构造函数即可。

对于第2点，如何写一个可迭代对象？其实只要包含begin()和end()方法，返回迭代器即可。但这里要返回什么迭代器呢？能否使用vector本身的迭代器？

看到第3点，我们就知道，必须自定义迭代器，并重载解引用运算符 operator*()，这样才能实现迭代器解引用后得到我们希望的std::vector对象，即一个包含100个id的分片。

开始开发

ChunkSpliter类与构造函数

首先我们声明ChunkSpliter类，并声明构造函数：

class ChunkSpliter {
public:
    explicit ChunkSpliter(const std::vector &container, const uint32_t &chunk_size = 100)
        : container_(container), chunk_size_(chunk_size) {}
private:
    const std::vector& container_;
    int chunk_size_;
};

在构造函数中，我们将传入的container和chunk_size存储到了类的成员变量中，以便后续在迭代器中使用。

开发迭代器

如果将一个类作为迭代器，需要重载下面这些运算符

• 自增 ++
• 等于/不等 == !=
• 解引用 *

对于我们这个需求，自增需要每次跳过100个数据，解引用需要生成一个std::vector对象。

另外，我们也需要保存原始的数组，以便解引用时生成它的一个切片。

于是我们声明如下：

class ChunkIterator {
public:
    explicit ChunkIterator(const std::vector &container, int index, int chunk_size) 
      : container_(container), index_(index), chunk_size_(chunk_size) {}
      
    bool operator==(const ChunkIterator& other) const { return index_ == other.index_;}
    bool operator!=(const ChunkIterator& other) const { return index_ != other.index_;}
    ChunkIterator& operator++();
    std::vector operator*();
    
private:
    const std::vector& container_;
    int index_;
    int chunk_size_;
};

其中，++ 和 * 运算符和没有定义，我们在类外定义：

// 重载自增运算符 ++
ChunkIterator& ChunkIterator::operator++() {
  index_ += chunk_size_;
  if (index_ > container_.size()) {
    index_ = container_.size();
  }
  return *this;
}

// 重载解引用运算符 *
std::vector ChunkIterator::operator*() {
  std::vector chunk;
  for (int i=index_; i

最后，为了上ChunkSpliter实例能成为可迭代对象，我们需要声明begin() 和 end()方法，返回ChunkIterator类型的迭代器：

class ChunkIterator {
// ...
public:
    ChunkIterator begin() {return ChunkIterator(container_, 0, chunk_size_);}
  ChunkIterator end() {return ChunkIterator(container_, container_.size(), chunk_size_);}
};

使用

好了，我们的代码已经完成了，让我们试试效果吧：

int main() {
  std::vector ids;
  for (int i = 0; i<1000; i++) {
    ids.push_back(i);
  }
  for (auto chunk : ChunkSpliter(ids, 100)) {
    for (auto v : chunk) {
      cout << v << " ";
    }
    cout << endl;
  }
}

进阶

为了进一步提高我们工具的泛用性，让它不局限于std::vector这一种类型，我们可以使用模板。聪明的读者，试一下如何做到吧。