Is this true.. ++i better than i++

[zoltan_ie]

Postfix increment and decrement operators create a temporary object when used while prefix operators don’t.

It is therefore more efficient to use the prefix version where possible, particularly in for loop constructs as whatever is used will be called multiple times in that case, i.e.,

we should use:

for (int nType = 0; nType < MM_NUM_TYPES; ++nType)
{
…
}

[Kheun]

Originally posted by zoltan_ie
Postfix increment and decrement operators create a temporary object when used while prefix operators don’t.

Yes, prefix operator are faster. If there is no need to use the original value, it is better to use prefix operator.

[zoltan_ie]

What I can't understand is why wasn't I told in college? I had to get into my first job to find that out. Also I've never seen it in use, how come?

any other things I should know about?

[dude_1967]

Hello,

In addition to the good answer so far, a few additional remarks can be made.

In loop constructions using integral counters, then all good compilers will put the loop counter in a register or on the stack. The counter will be properly initialized and incremented once upon every trip through the loop in each case at the end of the loop before the assembler instruction for the loop-end comparison. For these simple cases, there will be no performance differences between the two incrementing orders.

However, for complex types with specialized pre-increment and post-increment operators, the performance issues can be significant.

Sincerely, Chris.

[Philip Nicoletti]

The FAQ has a good summary of what has already been said:

http://www.codeguru.com/forum/showth...hreadid=231052

A discussion can also be found in one of Scott Meyers
"Effective C++" books. (I don't remember if it was the
first or second one).

[mwilliamson]

the two operators are usually defined like this:

class c
{
c& operator++() // prefix
{
m_int++;
return *this;
}

c operator++(int) // posfix
{
c old = *this;
m_int++;
return old;
}

int m_int;
};

So you can see that postfix has two copies and the prefix has none, so obviously it will be slower.

[Graham]

Small point: if you implement postfix ++ (and --) in terms of prefix, you only need to make modifications in one place:

c operator++(int) // posfix
{
    c old = *this;
    operator++();
    return old;
}