第二种形式更准确地表示您正在做什么。在你的例子中，你并不关心i的值，你所需要的只是迭代器中的下一个元素。

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

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

我在这里是魔鬼的倡导者，不推荐使用迭代器。主要原因是，我从桌面应用程序开发到游戏开发的所有源代码都没有我也不需要使用迭代器。一直以来，迭代器都不是必需的，其次，迭代器所带来的隐藏假设、代码混乱和调试噩梦，使其成为任何要求速度的应用程序都不要使用的典型例子。

即使从维护的角度来看，它们也是一团糟。这并不是因为它们，而是因为所有发生在幕后的混叠。我怎么知道你没有实现你自己的虚拟向量或数组列表，做一些完全不同的标准。我知道什么类型的当前，现在在运行时?你是否重载了运算符我没有时间检查你所有的源代码。我甚至不知道你使用的STL是什么版本?

迭代器的下一个问题是抽象漏洞，尽管有许多网站对此进行了详细讨论。

对不起，我没有，现在也没有看到迭代器有任何意义。如果他们抽象了列表或向量，而实际上你应该已经知道你要处理什么向量或列表，如果你不知道，那么你只会为将来的一些伟大的调试会话做好准备。

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

因为您没有将代码绑定到some_vector列表的特定实现。如果你使用数组下标，它必须是某种形式的数组;如果使用迭代器，则可以在任何列表实现上使用该代码。

容器独立性