这两个实现都是正确的，但我更喜欢'for'循环。由于我们已经决定使用Vector容器而不是其他容器，因此使用索引将是最好的选择。对vector使用迭代器将失去将对象放在连续内存块中的好处，这有助于简化对它们的访问。

我觉得这里的答案没有一个能解释为什么我喜欢把迭代器作为一个通用概念，而不是索引到容器中。请注意，我使用迭代器的大部分经验实际上并不是来自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数组时，它会退化为简单高效的指针算术，使其成为真正的零成本抽象。

比“告诉CPU做什么”(命令式)更好的是“告诉库你想要什么”(函数式)。

因此，你应该学习stl中的算法，而不是使用循环。

STL迭代器大部分都在那里，所以STL算法，比如sort，可以是容器独立的。

如果你只是想循环遍历一个向量中的所有项，只需使用索引循环样式。

对大多数人来说，它的输入更少，更容易解析。如果c++有一个简单的foreach循环，而不是过度使用模板魔法，那就太好了。

for( size_t i = 0; i < some_vector.size(); ++i )
{
   T& rT = some_vector[i];
   // now do something with rT
}
'

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

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

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

注:

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

这是现代c++灌输过程的一部分。迭代器是迭代大多数容器的唯一方法，所以即使对向量也使用迭代器，只是为了让自己进入正确的心态。说真的，这是我这么做的唯一原因——我不认为我曾经用不同类型的容器替换过一个向量。 哇，三周之后，还是有人投反对票。我想开玩笑是不值得的。

我认为数组索引可读性更好。它与其他语言中使用的语法以及老式C数组所使用的语法相匹配。它也更简洁。如果你的编译器有任何好的地方，效率应该是一个洗涤，而且几乎没有任何情况下，它是重要的。

即便如此，我仍然发现自己经常对向量使用迭代器。我相信迭代器是一个重要的概念，所以我尽可能地推广它。