Heya, I read the following in another post and can hardly believe it:

quote: 4. You should ALWAYS use the prefix increment when possible ... because the postfix increment has to make a copy ... and then increment the original. it++ is usually wrong or inefficient .. ++it is the correct way to do it ... as proof ... these lines: i = i + 1; i += 1; ++i; are all identical ... and generate identical code ... this one: i++ is NOT the same ... and is wrong for items without a copy constructor .. or wierd side effects.

Does VStdio''s optimizer not optimize this the proper way?? I don''t think for(i=0;i<10;i++) is slower than for(i=0;i<10;++i), is it? For now I only used the prefix notation with pointers. eg. ++dest = bla. Could somebody clear up my mind?? Gr, BoRReL

There are situations in which you particularly want postincrement, but in those cases where increment order is unimportant (like a for loop) use preincrement.

As for whether Visual Studio optimizes the for loop in question, it probably does since the order makes no difference. However, it doesn''t generally optimize your increment choices because it might damage your program logic.


To you it''s a Bently, to me it''s a blue car...
"Diddy"
P.Diddy

For integral types (like int) you won''t see any difference concerning the for loops. However if you use complex types (classes) the pre increment may be faster.

I don''t know what you intendent to show Magmai Kai Holmlor.
The problem is not the constructor call. But when you are using a postfix operator you have to manipulate your object while you must return its old version.
By the way, your example is a pre increment, if i is a member.

To elaborate on what VolkerG said, consider the simple example below:

int i = rand() % 4000;int j = i++; 

What''s the value of j after the assignment? (It''s the original value of i). What''s the value of i? (It''s 1 greater than the original value). How did that happen? The preceding code is evaluated as

j = i;i = i + 1; 

In other words, j = i is equivalent to a copy constructor for more complex data types (operator= is often implemented as a copy constructor, right?) Compare that to the following:

int i = rand() % 4000;int j = ++i; 

In this case, j is assigned the value of i after i has been incremented . There''ll still be a copy, but two values aren''t returned (i++ includes an implicit return of i.)

Operator precedence and associativity can be some freaky stuff at times.

Magmai: Thats a prefix-increment operator you defined. Of course there's no need to call the copy constructor in that one, since it should always return a reference to itself. However, in a postfix increment you must return the object as it was before the increment was performed. Therefore you cannot return a reference to *this (assuming the operator actually modifies something). You must create a copy of the object, then perform the increment, and finally return the copy.

e.g.

      // a prefix increment similar to the one you showed above:CMyInt& CMyInt::operator ++(){   ++i;  // i is a member   return *this;}   // a corresponding postfix increment:CMyInt CMyInt::operator ++(int)   // the int makes it a postfix{   CMyInt tmp(*this);   ++i;   return tmp;}      

If you can write the postfix version without calling a copy constructor, then please show it.

[EDIT]
Thought about this some more:
Actually the postfix increment operator above uses two copy constructor calls, one to create tmp, and one to copy tmp to the anonymous 'return variable' (perhaps an optimizing compiler can eliminate one of them). Both calls can be avoided by writing a specialized constructor, but then you still get one constructor call (and the code is slightly 'messier'). I don't think it's possible to write a post-increment without calling at least one constructor (assuming you want it to behave similarly to the post-increment for built-in types).
[/EDIT]

Edited by - Dactylos on October 22, 2001 5:09:25 PM

quote:Original post by Magmai Kai Holmlor
So it only matters if you overload the post-fix operator. For native types the post-fix operator doesn''t get called until _after the line it''s on finishes executing, even if there''s a pile of them on that line.

Actually, I''ve wondered about this a number of times. I''m convinced that the postfix increment operator gets called after the statement, which may not correlate to the line. ie,

int i = 1;int a = i++ + ++i; 

has some interesting behavior. a probably ends up as 3, and so does i. (i++) is evaluated after the statement i + d, where d = ++i = 2. So a = 1 + 2, then i = 2 + 1.

Fascinating, isn''t it?