Postfix iterator increment faster than prefix?

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?

At the bottom of this thread is a list of similar threads, in particular: Is prefix faster than postfix?

Also a quick discussion is on an external site here: Speed Optimization - Prefix vs. Postfix Incrementation and Decrementation - Music Intermix. It was one of the first results in a quick google search.

I was surprised this seems to even be the case. Out of curiosity, how many times did you "time" it? The more the better (accurate).

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.

You could try seeing the Assembly codes. They should be about the same.

Prefix operation is faster when compared to postfix operation.
Now let us see how both postfix and prefix work.

// postfix
iterator operator++(int)
{
iterator _Tmp = *this;
++*this;
return (_Tmp);
}

// prefix
iterator& operator++()
{
_Ptr = _Acc::_Next(_Ptr);
return (*this);
}
note: one integer dummy variable is used in postfix operation in order to distinguish weather it is a postfix operation or prefix operation. This dummy variable is never used.
(refer prefix / postfix overloading).

Eliza

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.