Speed accessing a std::vector by iterator vs by operator[]/index?

Question

Say, I have a

std::vector<SomeClass *> v; 

in my code and I need to access its elements very often in the program, looping them forward and backward .

Which is the fastest access type between those two ?

Iterator access:

std::vector<SomeClass *> v; std::vector<SomeClass *>::iterator i; std::vector<SomeClass *>::reverse_iterator j;  // i loops forward, j loops backward for( i = v.begin(), j = v.rbegin(); i != v.end() && j != v.rend(); i++, j++ ){     // some operations on v items } 

Subscript access (by index)

std::vector<SomeClass *> v; unsigned int i, j, size = v.size();  // i loops forward, j loops backward for( i = 0, j = size - 1; i < size && j >= 0; i++, j-- ){     // some operations on v items } 

And, does const_iterator offer a faster way to access vector elements in case I do not have to modify them?

Answer 1

The performance difference is likely negligable or none (the compiler might optimise them to be identical); you should worry about other things, like whether your program is correct (a slow but correct program is better than a fast and incorrect program). There are other advantages to using iterators though, such as being able to change the underlying container to one with no operator[] without modifying your loops. See this question for more.

const_iterators will most likely have none, or negligable, performance difference compared to ordinary iterators. They are designed to improve the correctness of your program by preventing modifying things that shouldn't be modified, not for performance. The same goes for the const keyword in general.

In short, optimisation should not be a concern of yours until two things have happened: 1) you have noticed it runs too slowly and 2) you have profiled the bottlenecks. For 1), if it ran ten times slower than it could, but is only ever run once and takes 0.1ms, who cares? For 2), make sure it's definitely the bottleneck, otherwise optimising it will have nearly no measurable effect on performance!

Answer 2

A simple loop-based benchmark has been fulfilled. I used VS 2010 SP1 (release configuration).

1. Use iterators (*it = *it + 1;)
2. Use indices (vs[i] = vs[i] + 1;)

In several billions of iterations the second approach turned out to be a bit faster, by 1%. The result (indices are slightly faster than iterators) is reproducible but the difference, as I said, is very small.