迭代器简介
c++中经常会用到这样的写法：
std::vector<int> 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<int> &ids);
现在我们有1万条id需要查询，就要分100次进行查询。那么我们首先要将其分成100组。当然这并不困难，但作为一名优秀的程序员，绝不能容忍每次都这样的重复性工作。于是我们希望做一个足够好用的工具，它可以这样使用：
std::vector<int> all_ids; // 假设其中已经有数据
for (const auto &chunk : ChunkSpliter(all_ids, 100)) {
HandleIds(chunk); // chunk中包含100个id
}
需求分析
分析一下上述效果，我们发现：
- ChunkSpliter是一个类，构造函数包含两个参数
- ChunkSpliter的实例是可迭代对象
- 对迭代器解引用，可以得到std::vector<int>对象
对于第1点，只需定义一个ChunkSpliter类，并显示声明构造函数即可。
对于第2点，如何写一个可迭代对象？其实只要包含begin()和end()方法，返回迭代器即可。但这里要返回什么迭代器呢？能否使用vector本身的迭代器？
看到第3点，我们就知道，必须自定义迭代器，并重载解引用运算符 operator*()，这样才能实现迭代器解引用后得到我们希望的std::vector<int>对象，即一个包含100个id的分片。
开始开发
ChunkSpliter类与构造函数
首先我们声明ChunkSpliter类，并声明构造函数：
class ChunkSpliter {
public:
explicit ChunkSpliter(const std::vector<int> &container, const uint32_t &chunk_size = 100)
: container_(container), chunk_size_(chunk_size) {}
private:
const std::vector<int>& container_;
int chunk_size_;
};
在构造函数中，我们将传入的container和chunk_size存储到了类的成员变量中，以便后续在迭代器中使用。
开发迭代器
如果将一个类作为迭代器，需要重载下面这些运算符
- 自增 ++
- 等于/不等 == !=
- 解引用 *
对于我们这个需求，自增需要每次跳过100个数据，解引用需要生成一个std::vector<int>对象。
另外，我们也需要保存原始的数组，以便解引用时生成它的一个切片。
于是我们声明如下：
class ChunkIterator {
public:
explicit ChunkIterator(const std::vector<int> &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<int> operator*();
private:
const std::vector<int>& container_;
int index_;
int chunk_size_;
};
其中，++ 和 * 运算符和没有定义，我们在类外定义：
// 重载自增运算符 ++
ChunkIterator& ChunkIterator::operator++() {
index_ += chunk_size_;
if (index_ > container_.size()) {
index_ = container_.size();
}
return *this;
}
// 重载解引用运算符 *
std::vector<int> ChunkIterator::operator*() {
std::vector<int> chunk;
for (int i=index_; i<index_+100 && i <container_.size(); i++) {
chunk.push_back(container_[i]);
}
return chunk;
}
最后，为了上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<int> 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<int>这一种类型，我们可以使用模板。聪明的读者，试一下如何做到吧。
