++u or u++ which is faster?

[The Doctor]

Hi all,

Recently I was asked the question about whether ++U or U++ is
faster if U is a user defined type. What's the answer?

Thank you

[Sumit Rajan]

The Doctor wrote:

Hi all,

Recently I was asked the question about whether ++U or U++ is
faster if U is a user defined type. What's the answer?

Thank you

http://www.parashift.com/c++-faq-lit...html#faq-13.12

--
Sumit Rajan <sumitrajan AT alexandria DOT cc>

[JKop]

The Doctor posted:

Hi all,

Recently I was asked the question about whether ++U or U++ is
faster if U is a user defined type. What's the answer?

Thank you

++u is faster.
Always use ++u. Never use u++ unless you need to.
-JKop

[Vaclav Haisman]

Usually operator ++ (int) is implemented like this:

T operator ++ (int)
{
T tmp = *this;
++*this;
return tmp;
}

If compiler isn't able to optimize away the initialization of the temporary
then using u++ is slower. That's why it is usually better to use
pre-increment/pre-decrement instead of post-decrement/post-increment.

VH

"The Doctor" <do****@nospam. com> wrote in message
news:Xn******** *************** ***********@61. 9.191.5...

Hi all,

Recently I was asked the question about whether ++U or U++ is
faster if U is a user defined type. What's the answer?

Thank you

[Method Man]

"The Doctor" <do****@nospam. com> wrote in message
news:Xn******** *************** ***********@61. 9.191.5...

Hi all,

Recently I was asked the question about whether ++U or U++ is
faster if U is a user defined type. What's the answer?

Thank you

The simple answer is when using U++, the object U needs to get copied twice
whereas with ++U, it need only be copied once.

So use ++U unless you specifically require the value of the post-increment.

[Chris Theis]

"JKop" <NU**@NULL.NULL > schrieb im Newsbeitrag
news:I0******** ***********@new s.indigo.ie...

The Doctor posted:

Hi all,

Recently I was asked the question about whether ++U or U++ is
faster if U is a user defined type. What's the answer?

Thank you

++u is faster.

This general statement is not true. It depends on the datatype and the
optimization of the compiler. Both types might be the same speed, but as you
say it's generally wise to use ++u.


Always use ++u. Never use u++ unless you need to.
-JKop

[Ioannis Vranos]

JKop wrote:

++u is faster.

For built-in types their speed is the same. For user defined types it
applies what you say.

--
Ioannis Vranos

http://www23.brinkster.com/noicys

[Simon Stienen]

Ioannis Vranos <iv*@guesswh.at .grad.com> wrote:

JKop wrote:

++u is faster.

For built-in types their speed is the same. For user defined types it
applies what you say.

So lets state:
++u is never slower.

Now it's perfect ;P
--
Simon Stienen <http://dangerouscat.ne t> <http://slashlife.de>
»What you do in this world is a matter of no consequence,
The question is, what can you make people believe that you have done.«
-- Sherlock Holmes in "A Study in Scarlet" by Sir Arthur Conan Doyle

[Rolf Magnus]

Method Man wrote:

"The Doctor" <do****@nospam. com> wrote in message
news:Xn******** *************** ***********@61. 9.191.5...

Hi all,

Recently I was asked the question about whether ++U or U++ is
faster if U is a user defined type. What's the answer?

Thank you

The simple answer is when using U++, the object U needs to get copied
twice whereas with ++U, it need only be copied once.

What would that extra copy be needed for? I can see U++ doing at most 2
copies (but usually one - or if the function gets inlined and the return
value is not used even both - of them getting optimized away) and ++U doing
none at all. Consider the operators for an iterator into a linked list:

class mylistiterator
{
public:
//...

mylistiterator& operator++()
{
node = node->next;
return *this;
} // no copy made

mylistiterator operator++(int)
{
myiterator ret = *this; // first copy
node = node->next;
return ret; // second one, usually optimized away
}
private:
mylist::node* node;
};

So it stands 0 to 2 copies for postfix++ vs. 0 for prefix++.

[Method Man]

> > The simple answer is when using U++, the object U needs to get copied

twice whereas with ++U, it need only be copied once.
What would that extra copy be needed for? I can see U++ doing at most 2
copies (but usually one - or if the function gets inlined and the return
value is not used even both - of them getting optimized away)

One time to store the old value, and another time for returning the old
value. Of course any optimizations are compiler-specific, dependent on
things like inlining, register variables, etc, or dependent on the
++operator code if U is a user type.

But I was speaking theoretically.
and ++U doing
none at all.
...

You're probably right here.

I guess the bottom line is U++ is never faster than ++U.