about performace between ++i and i++

  • Thread starter Thread starter Tony Johansson
  • Start date Start date
T

Tony Johansson

Hello!!

Which have best performance between i++ or ++i.
Is it exact the same or is it some very small difference in performace
betwwwn these two.

//Tony
 
"Tony Johansson" <[email protected]> a écrit dans le message de
[email protected]...

| Which have best performance between i++ or ++i.
| Is it exact the same or is it some very small difference in performace
| betwwwn these two.

What's the point of comparing performance on two totally different operators
?

If you want to increment the value after using it, then use i++.

If you want to increment the value before using it, then use ++i.

Performance really isn't the issue here.

Joanna
 
Tony Johansson said:
Which have best performance between i++ or ++i.
Is it exact the same or is it some very small difference in performace
betwwwn these two.
Click to expand...

Obviously, when used in an expression whose value is used, these have
different semantics, so I won't talk about that.

As freestanding expression statements, they are compiled to the
following IL, respectively, where 'i' is the one and only local
variable:

i++;
ldloc.0
ldc.i4.1
add
stloc.0

++i;
ldloc.0
ldc.i4.1
add
stloc.0

i = i + 1;
ldloc.0
ldc.i4.1
add
stloc.0

i += 1;
ldloc.0
ldc.i4.1
add
stloc.0

So, there is no difference.

-- Barry
 
Hello!!

That was the answer I wanted and not the answer I recived from Joanna

//Tony
 
Hello!!

I just wonder this person Berry is saying that i++ and ++i is compiled
into the same IL code and therefore I wonder if it's possible for me to see
this for myself.
I'm sure he is right but I just wonder if I can see it also in any way.

//Tony
 
because :

for ( int i=0 ; i<maxidx ; ++i )
for ( int i=0 ; i<maxidx ; i++ )

in both cases the value is used after the operation is applied
 
"gerry" <[email protected]> a écrit dans le message de (e-mail address removed)...

| because :
|
| for ( int i=0 ; i<maxidx ; ++i )
| for ( int i=0 ; i<maxidx ; i++ )
|
| in both cases the value is used after the operation is applied

But if you do this :

int i = 0;

while (i < maxidx)
Console.WriteLine(i++);

i = 0;

while (i < maxidx)
Console.WriteLine(++i);

You get different results; which is why I mentioned that the two operators
(pre and post) do different things, therefore performance is not an issue in
assessing the two operators. If you want to do two different things, then
you choose the correct operator for the job, performance comparison in this
situation is like comparing apples to bananas.

Joanna
 
"Tony Johansson" <[email protected]> a écrit dans le message de
L%[email protected]...

| That was the answer I wanted and not the answer I recived from Joanna

Barry's answer cannot be true for the example where you are not simply using
the operator in a for loop declaration. See my reply to Gerry.

while (i < 10)
console.WriteLine(++i);

IL_0005: ldloc.0
IL_0006: ldc.i4.1
IL_0007: add
IL_0008: dup
IL_0009: stloc.0

while (i < 10)
console.WriteLine(++i);

IL_0005: ldloc.0
IL_0006: dup
IL_0007: ldc.i4.1
IL_0008: add
IL_0009: stloc.0

Joanna
 
Tony Johansson said:
I just wonder this person Berry is saying that i++ and ++i is compiled
into the same IL code and therefore I wonder if it's possible for me to see
this for myself.
I'm sure he is right but I just wonder if I can see it also in any way.
Click to expand...

Yup - use ildasm.
 
I don't understand why are dismissing the very common situations where the
difference between these 2 operators is irrelevant and could very well be a
significant performance concern ?

in your opinion, given the 2 for statements below - which is the "correct
operator for the job" and why ?
 
"gerry" <[email protected]> a écrit dans le message de %[email protected]...

|I don't understand why are dismissing the very common situations where the
| difference between these 2 operators is irrelevant and could very well be
a
| significant performance concern ?

Tony's original post didn't say anything about the context in which he
wished to use the operators in question. I must say, I wasn't aware of the
for(...) case where the difference is optimised away and am struggling to
think of any other case where the compiler pulls a similar trick.

It was with the majority of situations where it does make a difference in
mind that I replied as I did.

| in your opinion, given the 2 for statements below - which is the "correct
| operator for the job" and why ?

The choice is simply decided by whether you want to use the value before or
after you have incremented it.

Joanna
 
Joanna Carter said:
"Tony Johansson" <[email protected]> a écrit dans le message de
L%[email protected]...

| That was the answer I wanted and not the answer I recived from Joanna

Barry's answer cannot be true
Click to expand...

My answer, in total, is true, Joanna. There are qualifications at the
start. I'll quote them again, in case you missed them:
Obviously, when used in an expression whose value is used, these have
different semantics, so I won't talk about that.

As freestanding expression statements, they are compiled to the
following IL, respectively, where 'i' is the one and only local
variable:
Click to expand...

To reiterate, my answer applies to freestanding expression statements.

-- Barry
 
Joanna Carter said:
why I mentioned that the two operators
(pre and post) do different things,
Click to expand...

They have different semantics only when the value of the expression is
used. Since the operators also have side-effects, they are commonly used
for their side effects alone. The only meaningful interpretation of the
question, then, is when the value of the expression *isn't* used, and
the expressions are used as expression statements, for their
side-effects alone.

*That* is why it *is* meaningful to talk about relative performances,
because the side-effects are the *same*. In very naive implementation,
these two operators could have quite different implementations. For
example, if the compiler wasn't aware of the common idiom of using an
pre or post increment expression for its side-effects alone, it might
use this IL instead:

++i;
ldloc.0
ldc.i4.1
add
dup
stloc.0
pop

i++;
ldloc.0
dup
ldc.i4.1
add
stloc.0
pop

And then these instructions, with a very naive JIT, might compile to
different machine code instructions, which might perform differently.

-- Barry
 
Joanna Carter said:
| in your opinion, given the 2 for statements below - which is the "correct
| operator for the job" and why ?

The choice is simply decided by whether you want to use the value before or
after you have incremented it.
Click to expand...

One traditional answer in C++ is that '++i' should be used, because when
'i' is a user-defined type, the 'i++' operator must return a copy while
'++i' can return a reference. Of course, the difference is pretty much
negligible in real-world applications.

That was why the question was asked, IMHO.

-- Barry
 
It was with the majority of situations where it does make a difference in
mind that I replied as I did.
Click to expand...

Do you really use pre and post-increment operators *usually* in the
context of a larger statement? I almost never do, because every time I
do, it takes me longer to read the code afterwards than if I'd done:

most_of_statement;
i++;

or

i++;
most_of_statement;

The same is true for the majority of code I've read in open source
projects, colleagues etc.
 
"Jon Skeet [C# MVP]" <[email protected]> a écrit dans le message de (e-mail address removed)...

| Do you really use pre and post-increment operators *usually* in the
| context of a larger statement? I almost never do, because every time I
| do, it takes me longer to read the code afterwards than if I'd done:
|
| most_of_statement;
| i++;

I can see how using i++ or ++i as a single statement would behave
identically in as far as it achieved the same result and, not having
bothered to check the IL, assumed that any performance difference would have
to be so small as to be negligable.

The only occasion I could envisage a difference would be if the order of
value changing mattered, and on such an occasion, you might not have the
luxury of "tweaking" performance due to the integrity of the algorithm.

In either case, I really can't see any difference in performance being that
important in the scheme of things.

Joanna
 
"Barry Kelly" <[email protected]> a écrit dans le message de (e-mail address removed)...

| My answer, in total, is true, Joanna. There are qualifications at the
| start. I'll quote them again, in case you missed them:

Yup, missed that, never mind we all learn something new every day :-)

Joanna
 
Joanna Carter said:
"Jon Skeet [C# MVP]" <[email protected]> a écrit dans le message de
(e-mail address removed)...

| Do you really use pre and post-increment operators *usually* in the
| context of a larger statement? I almost never do, because every time I
| do, it takes me longer to read the code afterwards than if I'd done:
|
| most_of_statement;
| i++;

I can see how using i++ or ++i as a single statement would behave
identically in as far as it achieved the same result and, not having
bothered to check the IL, assumed that any performance difference would have
to be so small as to be negligable.

The only occasion I could envisage a difference would be if the order of
value changing mattered, and on such an occasion, you might not have the
luxury of "tweaking" performance due to the integrity of the algorithm.

In either case, I really can't see any difference in performance being that
important in the scheme of things.
Click to expand...

That's certainly true - I was just interested in your view that the
"majority of situations" consists of ones where the value is used so
the choice of pre/post makes a difference. I'm always interested in
different programming styles :)
 
"Jon Skeet [C# MVP]" <[email protected]> a écrit dans le message de (e-mail address removed)...

| I was just interested in your view that the
|"majority of situations" consists of ones where the value is used so
| the choice of pre/post makes a difference. I'm always interested in |
| different programming styles :)

Yes, I suppose I'm one of those programmers who likes to make use of "most"
of the language features available :-)

I will use ? : where appropriate instead of an if..else as well. Maybe it's
to do with thinking that the more cryptic the code, the nearer it is to
assembler, which I never really got the hang of. ;~}

Joanna
 
Joanna said:
"Jon Skeet [C# MVP]" <[email protected]> a écrit dans le message de (e-mail address removed)...

| I was just interested in your view that the
|"majority of situations" consists of ones where the value is used so
| the choice of pre/post makes a difference. I'm always interested in |
| different programming styles :)

Yes, I suppose I'm one of those programmers who likes to make use of "most"
of the language features available :-)
Click to expand...

If your programming tasks are trivial, use difficult techniques to make
them challening. ;)
I will use ? : where appropriate instead of an if..else as well. Maybe it's
to do with thinking that the more cryptic the code, the nearer it is to
assembler, which I never really got the hang of. ;~}
Click to expand...

If the code was hard to write, it should be hard to read. ;)

The problem with the close-to-assembly theory is that simple code in
many cases are more efficient than cryptic one-liners, and also that
assenbly code is actually made up of a lot of simple operations.
 
Back
Top