Is there a performance difference between i++ and ++i in C?

Executive summary: No.

i++ could potentially be slower than ++i, since the old value of imight need to be saved for later use, but in practice all moderncompilers will optimize this away.

We can demonstrate this by looking at the code for this function,both with ++i and i++.

$ cat i++.cextern void g(int i);void f(){    int i;    for (i = 0; i < 100; i++)        g(i);}

The files are the same, except for ++i and i++:

$ diff i++.c ++i.c6c6<     for (i = 0; i < 100; i++)--->     for (i = 0; i < 100; ++i)

We'll compile them, and also get the generated assembler:

$ gcc -c i++.c ++i.c$ gcc -S i++.c ++i.c

And we can see that both the generated object and assembler files are the same.

$ md5 i++.s ++i.sMD5 (i++.s) = 90f620dda862cd0205cd5db1f2c8c06eMD5 (++i.s) = 90f620dda862cd0205cd5db1f2c8c06e$ md5 *.oMD5 (++i.o) = dd3ef1408d3a9e4287facccec53f7d22MD5 (i++.o) = dd3ef1408d3a9e4287facccec53f7d22

From Efficiency versus intent by Andrew Koenig :

First, it is far from obvious that ++i is more efficient than i++, at least where integer variables are concerned.

And :

So the question one should be asking is not which of these two operations is faster, it is which of these two operations expresses more accurately what you are trying to accomplish. I submit that if you are not using the value of the expression, there is never a reason to use i++ instead of ++i, because there is never a reason to copy the value of a variable, increment the variable, and then throw the copy away.

So, if the resulting value is not used, I would use ++i. But not because it is more efficient: because it correctly states my intent.

A better answer is that ++i will sometimes be faster but never slower.

Everyone seems to be assuming that i is a regular built-in type such as int. In this case there will be no measurable difference.

However if i is complex type then you may well find a measurable difference. For i++ you must make a copy of your class before incrementing it. Depending on what's involved in a copy it could indeed be slower since with ++it you can just return the final value.

Foo Foo::operator++(){  Foo oldFoo = *this; // copy existing value - could be slow  // yadda yadda, do increment  return oldFoo;}

Another difference is that with ++i you have the option of returning a reference instead of a value. Again, depending on what's involved in making a copy of your object this could be slower.

A real-world example of where this can occur would be the use of iterators. Copying an iterator is unlikely to be a bottle-neck in your application, but it's still good practice to get into the habit of using ++i instead of i++ where the outcome is not affected.