假设some_vector是用链表实现的。然后，在第i个位置请求一个项需要执行i个操作来遍历节点列表。现在，如果您使用迭代器，一般来说，它将尽最大努力尽可能高效(在链表的情况下，它将维护一个指向当前节点的指针，并在每次迭代中推进它，只需要一个操作)。

所以它提供了两件事:

使用的抽象:你只想迭代一些元素，你不关心如何去做 性能

因为您没有将代码绑定到some_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数组时，它会退化为简单高效的指针算术，使其成为真正的零成本抽象。

除了所有其他优秀的答案之外……Int对向量来说可能不够大。相反，如果你想使用索引，使用size_type为你的容器:

for (std::vector<Foo>::size_type i = 0; i < myvector.size(); ++i)
{
    Foo& this_foo = myvector[i];
    // Do stuff with this_foo
}

已经有几个好观点了。我还有一些补充意见:

Assuming we are talking about the C++ standard library, "vector" implies a random access container that has the guarantees of C-array (random access, contiguos memory layout etc). If you had said 'some_container', many of the above answers would have been more accurate (container independence etc). To eliminate any dependencies on compiler optimization, you could move some_vector.size() out of the loop in the indexed code, like so: const size_t numElems = some_vector.size(); for (size_t i = 0; i Always pre-increment iterators and treat post-increments as exceptional cases.

for (some_iterator = some_vector.begin(); some_iterator != some_vector.end(); ++some_iterator){ //do stuff }

假设和可索引std::vector<>类似于容器，没有好的理由选择一个而不是另一个，按顺序遍历容器。如果必须频繁引用较旧或较新的元素索引，则使用索引版本更合适。

一般来说，使用迭代器是首选的，因为算法会使用它们，并且可以通过改变迭代器的类型来控制(并隐式记录)行为。数组位置可以用来代替迭代器，但是语法上的差异会很明显。

我不使用迭代器的原因与我不喜欢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，因为这样你就不能清楚地看到这个值来自哪个数组。