Hopefully this is not too general or weird of a question. Also, couldn't find it on Google, don't whether this is just too dumb of a question or whether I fail at Google.
So, I forget where I read this from but, it said that using '++x' (or whatever other variable) is somehow more optimized or whatever you might call this than, 'x++'.
So, is this just a looks thing or is one truly faster? Like, they do the exact same thing so, that is why I am asking.
They're doing different things. The first is pre-increment, and the second is post-increment. If you use either alone on a line, you won't notice the difference. But if you do (for instance):
a = x++
or
a = ++x
you will. With post-increment, you get the value, then increment. With pre-increment, you increment, then get the value. See http://en.wikipedia.org/wiki/++#Use_in_programming_languages for a brief explanation (they use JS as an example, but it applies equally to C#)
EDIT: By popular demand (and to refute a couple exaggerations), here's a little about performance with primitives in C++. Take this example program:
int main()
{
int a;
int x = 14, y = 19;
a = x++;
a = ++y;
}
It compiles (g++, just -S) to the below on x86. I have removed irrelevant lines. Let's look at what's happening and see if unnecessary duplicates are being made.:
# Obvious initialization.
movl $14, -12(%ebp)
movl $19, -16(%ebp)
movl -12(%ebp), %eax # This is moving "old x" to the accumulator.
movl %eax, -8(%ebp) # Moving accumulator to a.
addl $1, -12(%ebp) # Increment x (post-increment).
addl $1, -16(%ebp) # Increment y (pre-increment)
movl -16(%ebp), %eax # Move "new y" to accumulator.
movl %eax, -8(%ebp) # Move accumulator to a.
We're done.
As you can see, in this example, the exact same operations are required in each case. Exactly 2 movl, and 1 addl. The only difference is the order (surprised?). I think this is fairly typical of examples where the increment statement's value is used at all.
If you are optimizing at this level you are wasting time. There are surely some loops in your program that could get faster.
Well, the preincrement operation ("++x") returns the result of the variable after the increment has been done, whereas the postincrement operation ("x++") returns the result of the variable before the increment has been done. The compiler COULD (and strong emphasis on COULD) optimize easier using the preincrement (because only one value is effectively being used; in the postincrement case, there are two values; the value of the variable before the increment, and the value of the variable after; the compiler might be able to optimize the preincrement to use the storage that contains the variable itself).
Note that this is very much theoretical; it very much depends on your compiler optimization. In most situations, and for most purposes, they'll effectively be equivalently efficient.
In C# (since that's mentioned in the question tags), the two shouldn't be too different, if used standalone.
In C++, ++x is to be preferred over x++, because (for classes with overloaded operators), best practice is for post-increment to be implemented in terms of the pre-increment.
// pre-increment (note, return by reference)
T& operator++() {
// ... do its thing
}
// post-increment (note, return by value)
T operator++(int) {
T saved(*this);
++*this; // or: operator++();
return saved;
}
It's not a matter of optimization, it's a matter of functionality.
Explained here... In C# what is the difference between myInt++ and ++myInt?
x++ will increment x, but return its old value. ++x increments x and returns the new value. The difference is that x++ needs to declare a hidden temp variable to store the old value.
Here's a good summary of pre- and post-increment.
The summary is that pre-increment, ++x, is simpler and should maybe be preferred. However, in practice, I doubt it makes a significant difference.
I think it's more important to understand the difference in their function rather than worry about their speed. Use the write one for the write job.
I thought it was an interesting question. I didn't know that there's a performance difference when use an increment operator either from right side of a variable or left. Apparently there's in C++ (thanks Chris Jester-Young, +1 for you).
I decided for my self to see what CLR does with this operator. I created two functions:
private int IncrementRight(int n)
{
return n++;
}
private int IncrementLeft(int n)
{
return ++n;
}
I looked at the compiled code in Reflector. IL looks almost identical; the difference is only in order of OpCodes.
Here's the IL for both methods:
.method private hidebysig instance int32 IncrementLeft(int32 n) cil managed
{
.maxstack 8
L_0000: ldarg.1
L_0001: ldc.i4.1
L_0002: add
L_0003: dup
L_0004: starg.s n
L_0006: ret
}
.method private hidebysig instance int32 IncrementRight(int32 n) cil managed
{
.maxstack 8
L_0000: ldarg.1
L_0001: dup
L_0002: ldc.i4.1
L_0003: add
L_0004: starg.s n
L_0006: ret
}
Therefore, my conclusion is that there's no difference in C# when you use increment operators.
Pre vs Post increment (fogcreek)
Preincrement is more efficient than postincrement, because for postincrement the object must increment itself and then return a temporary containing its old value. Note that this is true even for builtins like int!
The temporary thing is what makes the difference.
Larger the object the worse off the memory usage is.
Correct me if I'm wrong please.
Used by itself (where the return value is not used), the compiler should be smart enough to produce the same code for both.
And, you should try to use it on it's own, unless you specifically need the post-increment or pre-increment behaviour for something. I have found that code like this:
r[ofs] = *(p++);
is somewhat slower than:
r[ofs] = *p;
p++;
So, if in doubt keep it simple and break it apart on separate lines if you are in a tight loop and need the litte extra.
Edit:
Changed the example code to some actual code where I observed this.
