Thread: Postfix iterator increment faster than prefix?

Originally Posted by Optimizinator

Hello guys,

After performing some C++ testing on vector iterators. I have found that the postfix-increment is faster.

Code:

#include <vector>
#include <stdlib.h>
using namespace std;

class TestClass {
	int var1, var2;
	float floatone;
	public: inline TestClass() {}
};

#define USE_POSTFIX 1

int main( int argc, char *argv[ ] ) {
	vector<TestClass> vectorz( 10000 );
	vector<TestClass>::iterator viterator;
	volatile int garbage = 0;
	for ( unsigned int i = 0; i < 10000; i += 1 ) {
		for ( viterator = vectorz.begin(); viterator != vectorz.end();)
		{
			garbage += 1; // make sure optimizer doesn't balete the loop
			#ifdef USE_POSTFIX
				viterator++;
			#else
				++viterator;
			#endif
		}
	}
}

Timings: Prefix 5.19s user time, Postfix 4.63s user time.

Any of you guys know why this might be the case?

It's simply not the case; the only explanation is that you did something wrong. I don't suppose you did this?:

Code:

#define USE_POSTFIX 0

Also, sometimes the second run is faster. There's no way you'll consistently get results like what you've posted.

Your benchmarks mean nothing when you don't provide the following information:

1. What Compiler was used
2. Debug or Release Build
3. What optimisation settings were used
4. How the results were timed

All bets are off if all the bits and pieces are declared inline. If iterator:: operator++() is inline, and the iterator copy constructor is inline (both are likely to be the case), then the compiler gets an unfettered view of the actual semantics of the operation. It is able to see that the prior value of the iterator is unused after the post-increment, and it is able to see that the iterator's copy constructor has no side-effects. Therefore the compiler eliminate the construction and return of the prior value of the iterator.

The fact that the postfix version comes out faster than the prefix version is probably just the vagaries of the particular compiler and optimization settings.

Anyway, the traditional wisdom is from the old days. You actually wrote a program to test the assumption, and, provided you haven't made a mistake somewhere, you learned something counterintuitive. Bravo.

Originally Posted by elizas

This dummy variable is never used.

What do you mean the dummy var is never used? You've already used it (returned it).

[off-topic]
How did you ignore "Use [code] tags" warning?

I believe elizas was referring to the int in the iterator operator++(int).
That variable is never used.

Aha, right, the type name.