Iterating over a vector is a pretty simple task we get to do pretty often. It can be achieved in quite a few ways:

• Using normal random access (operator[] with index).
• Using std::iterator.
• Using std::for_each algorithm.

I set out to check the runtime differences between all these options, and the results turned out to be a little surprising (or not).

Let me present the setup:

#include <algorithm>
#include <vector>

typedef std::vector<int> vec;

struct func {
    void operator () (int &n) const {
        n *= 2;
    }
};

void idx (vec &v, func &f) {
    for (size_t i=0;i<v.size();++i)
        f(v[i]);
}

void iterate (vec &v, func &f) {
    for (vec::iterator i=v.begin();i!=v.end();++i)
        f(*i);
}

void foreach (vec &v, func &f) {
    std::for_each(v.begin(), v.end(), f);
}

I used the Timer class (presented here) to time all the different options, in the following manner:

#include "timer.hpp"

int main () {
    Timer t("iterate");

    vec v(30000, 2);
    func f;

    for (unsigned i=30000;i;--i)
        iterate(v, f);

    return 0;
}

The tests were run on my own system; Windows Vista, Visual Studio 2008 (release config), Intel core2 quad q9450, 4gb ram. The observed results were the following:

idx: 1.188secs.

iterate: 6.813secs.

foreach: 0.709secs.

Looks like using the foreach algorithm is the fastest way, followed by normal random-access (using operator[]), while the usage of iterators seems to be the slowest by far.

Edit: as it turns out, the usage of checked iterators is enabled in visual studio by default, both in debug and in release modes. As you could guess, this fact has a great effect on the results. When the feature is disabled (#define _SECURE_SCL 0), the results are totally different; std::for_each still wins, but the margins are significantly smaller:

idx: 0.686secs.

iterate: 0.701secs.

foreach: 0.682secs.

I would like to thank Halbling for raising the question.