分离关注点

将迭代代码从循环的“核心”关注点中分离出来是非常好的。这几乎是一个设计决策。

实际上，通过索引迭代将您与容器的实现联系在一起。向容器请求开始和结束迭代器，使循环代码可用于其他容器类型。

同样，在std::for_each方法中，你告诉集合要做什么，而不是询问它的内部信息

0x标准将引入闭包，这将使这种方法更容易使用-看看例如Ruby的[1..6]的表达能力。每个{|i| print i;}……

性能

但是可能有一个被监督的问题是，使用for_each方法产生了一个并行迭代的机会——intel线程块可以将代码块分布在系统中的处理器数量上!

注意:在发现算法库，特别是foreach之后，我花了两三个月的时间写了非常小的“helper”操作符结构，这会让其他开发人员发疯。在这之后，我回到了一个实用的方法-小循环体不应该再有foreach了:)

关于迭代器的必读参考书是《扩展STL》。

GoF在迭代器模式的末尾有一小段话，讲的是这种迭代;它被称为“内部迭代器”。这里也看看。

迭代器的另一个好处是，它们更好地允许你表达(和执行)你的const-preference。这个例子确保你不会在循环中改变向量:

for(std::vector<Foo>::const_iterator pos=foos.begin(); pos != foos.end(); ++pos)
{
    // Foo & foo = *pos; // this won't compile
    const Foo & foo = *pos; // this will compile
}

我觉得这里的答案没有一个能解释为什么我喜欢把迭代器作为一个通用概念，而不是索引到容器中。请注意，我使用迭代器的大部分经验实际上并不是来自c++，而是来自Python等高级编程语言。

迭代器接口对函数的使用者施加的要求更少，这允许使用者使用它做更多的事情。

如果你所需要的只是能够进行前向迭代，那么开发人员就不局限于使用可索引容器——他们可以使用任何实现运算符++(T&)、运算符*(T)和运算符!=(const &T, const &T)。

#include <iostream>
template <class InputIterator>
void printAll(InputIterator& begin, InputIterator& end)
{
    for (auto current = begin; current != end; ++current) {
        std::cout << *current << "\n";
    }
}

// elsewhere...

printAll(myVector.begin(), myVector.end());

你的算法适用于你需要的情况-迭代一个向量-但它也可以用于你不一定预期的应用程序:

#include <random>

class RandomIterator
{
private:
    std::mt19937 random;
    std::uint_fast32_t current;
    std::uint_fast32_t floor;
    std::uint_fast32_t ceil;

public:
    RandomIterator(
        std::uint_fast32_t floor = 0,
        std::uint_fast32_t ceil = UINT_FAST32_MAX,
        std::uint_fast32_t seed = std::mt19937::default_seed
    ) :
        floor(floor),
        ceil(ceil)
    {
        random.seed(seed);
        ++(*this);
    }

    RandomIterator& operator++()
    {
        current = floor + (random() % (ceil - floor));
    }

    std::uint_fast32_t operator*() const
    {
        return current;
    }

    bool operator!=(const RandomIterator &that) const
    {
        return current != that.current;
    }
};

int main()
{
    // roll a 1d6 until we get a 6 and print the results
    RandomIterator firstRandom(1, 7, std::random_device()());
    RandomIterator secondRandom(6, 7);
    printAll(firstRandom, secondRandom);

    return 0;
}

试图实现一个方括号操作符来做类似于这个迭代器的事情是不合理的，而迭代器的实现相对简单。方括号操作符还暗示了类的功能——可以将其索引到任意点——实现起来可能比较困难或效率较低。

迭代器也用于修饰。人们可以编写迭代器，在其构造函数中接受迭代器并扩展其功能:

template<class InputIterator, typename T>
class FilterIterator
{
private:
    InputIterator internalIterator;

public:
    FilterIterator(const InputIterator &iterator):
        internalIterator(iterator)
    {
    }

    virtual bool condition(T) = 0;

    FilterIterator<InputIterator, T>& operator++()
    {
        do {
            ++(internalIterator);
        } while (!condition(*internalIterator));

        return *this;
    }

    T operator*()
    {
        // Needed for the first result
        if (!condition(*internalIterator))
            ++(*this);
        return *internalIterator;
    }

    virtual bool operator!=(const FilterIterator& that) const
    {
        return internalIterator != that.internalIterator;
    }
};

template <class InputIterator>
class EvenIterator : public FilterIterator<InputIterator, std::uint_fast32_t>
{
public:
    EvenIterator(const InputIterator &internalIterator) :
        FilterIterator<InputIterator, std::uint_fast32_t>(internalIterator)
    {
    }

    bool condition(std::uint_fast32_t n)
    {
        return !(n % 2);
    }
};


int main()
{
    // Rolls a d20 until a 20 is rolled and discards odd rolls
    EvenIterator<RandomIterator> firstRandom(RandomIterator(1, 21, std::random_device()()));
    EvenIterator<RandomIterator> secondRandom(RandomIterator(20, 21));
    printAll(firstRandom, secondRandom);

    return 0;
}

虽然这些玩具看起来很普通，但不难想象使用迭代器和迭代器装饰器在一个简单的接口上做强大的事情——例如，用一个从单个结果构造模型对象的迭代器装饰数据库结果的仅向前迭代器。这些模式使无限集的内存高效迭代成为可能，并且，使用像我上面写的过滤器，可能会延迟结果的计算。

c++模板的部分强大之处在于你的迭代器接口，当应用于固定长度的C数组时，它会退化为简单高效的指针算术，使其成为真正的零成本抽象。

如果你可以访问c++ 11的特性，那么你也可以使用一个基于范围的for循环来迭代你的vector(或任何其他容器)，如下所示:

for (auto &item : some_vector)
{
     //do stuff
}

这个循环的好处是，您可以直接通过item变量访问vector的元素，而不会有搞乱索引或在解引用迭代器时出错的风险。此外，占位符auto可以防止您重复容器元素的类型， 这使您更接近于容器无关的解决方案。

注:

如果您需要循环中的元素索引，并且容器中存在操作符[](并且对您来说足够快)，那么最好采用第一种方法。 基于范围的for循环不能用于在容器中添加/删除元素。如果你想这样做，那么最好坚持布莱恩·马修斯给出的解决方案。 如果你不想改变容器中的元素，那么你应该如下所示使用关键字const: for (auto const &item: some_vector){…}。

我应该指出你也可以打电话

Std::for_each(some_vector.begin()， some_vector.end()， &do_stuff);

我不使用迭代器的原因与我不喜欢foreach-statements的原因相同。当有多个内部循环时，如果不记住所有的局部值和迭代器名称，就很难跟踪全局/成员变量。我发现有用的是在不同的情况下使用两组指标:

for(int i=0;i<anims.size();i++)
  for(int j=0;j<bones.size();j++)
  {
     int animIndex = i;
     int boneIndex = j;


     // in relatively short code I use indices i and j
     ... animation_matrices[i][j] ...

     // in long and complicated code I use indices animIndex and boneIndex
     ... animation_matrices[animIndex][boneIndex] ...


  }

例如，我甚至不想将“animation_matrices[I]”缩写为一些随机的“anim_matrix”-name -iterator，因为这样你就不能清楚地看到这个值来自哪个数组。