Difference between pre-increment and post-increment in a loop?

Question

Is there a difference in ++i and i++ in a for loop? Is it simply a syntax thing?

Bolognese

Dupe: #467822 – Cobelligerent

I dont think it should have language tags the unary operators are in (most) languages... – Enos

I'm amazed at how many answers completely missed the point of the question. – Hobble

Perhaps we should be amazed that no one edited the question to be more clear :) – Cobelligerent

This question could apply to C, Java, C++, PHP, C#, Javascript, JScript, Objective C: en.wikipedia.org/wiki/Category:C_programming_language_family – Kinna

I retagged since those two tags are the easiest way to find questions of this nature. I also went through others that didn't have cohesive tags and gave them cohesive tags. – Pirandello

possible duplicate of Is there a performance difference between i++ and ++i in C++? – Vermination

gist.github.com/3364309 – Event

Good answer posted here: https://mcmap.net/q/23925/-post-increment-and-pre-increment-within-a-39-for-39-loop-produce-same-output-duplicate – Firebug

Answer 1

a++ is known as postfix.

add 1 to a, returns the old value.

++a is known as prefix.

add 1 to a, returns the new value.

C#:

string[] items = {"a","b","c","d"};
int i = 0;
foreach (string item in items)
{
    Console.WriteLine(++i);
}
Console.WriteLine("");

i = 0;
foreach (string item in items)
{
    Console.WriteLine(i++);
}

Output:

1
2
3
4

0
1
2
3

foreach and while loops depend on which increment type you use. With for loops like below it makes no difference as you're not using the return value of i:

for (int i = 0; i < 5; i++) { Console.Write(i);}
Console.WriteLine("");
for (int i = 0; i < 5; ++i) { Console.Write(i); }

0 1 2 3 4
0 1 2 3 4

If the value as evaluated is used then the type of increment becomes significant:

int n = 0;
for (int i = 0; n < 5; n = i++) { }

Kinna

This is not even what the user asked for. – Sweepings

Answer 2

Pre-increment ++i increments the value of i and evaluates to the new incremented value.

int i = 3;
int preIncrementResult = ++i;
Assert( preIncrementResult == 4 );
Assert( i == 4 );

Post-increment i++ increments the value of i and evaluates to the original non-incremented value.

int i = 3;
int postIncrementResult = i++;
Assert( postIncrementtResult == 3 );
Assert( i == 4 );

---

In C++, the pre-increment is usually preferred where you can use either.

This is because if you use post-increment, it can require the compiler to have to generate code that creates an extra temporary variable. This is because both the previous and new values of the variable being incremented need to be held somewhere because they may be needed elsewhere in the expression being evaluated.

So, in C++ at least, there can be a performance difference which guides your choice of which to use.

This is mainly only a problem when the variable being incremented is a user defined type with an overridden ++ operator. For primitive types (int, etc) there's no performance difference. But, it's worth sticking to the pre-increment operator as a guideline unless the post-increment operator is definitely what's required.

There's some more discussion here.

In C++ if you're using STL, then you may be using for loops with iterators. These mainly have overridden ++ operators, so sticking to pre-increment is a good idea. Compilers get smarter all the time though, and newer ones may be able to perform optimizations that mean there's no performance difference - especially if the type being incremented is defined inline in header file (as STL implementations often are) so that the compiler can see how the method is implemented and can then know what optimizations are safe to perform. Even so, it's probably still worth sticking to pre-increment because loops get executed lots of times and this means a small performance penalty could soon get amplified.

---

In other languages such as C# where the ++ operator can't be overloaded there is no performance difference. Used in a loop to advance the loop variable, the pre and post increment operators are equivalent.

Correction: overloading ++ in C# is allowed. It seems though, that compared to C++, in C# you cannot overload the pre and post versions independently. So, I would assume that if the result of calling ++ in C# is not assigned to a variable or used as part of a complex expression, then the compiler would reduce the pre and post versions of ++ down to code that performs equivalently.

Annieannihilate

Wouldn't it have been great if C++ was named ++C indicating that you can write a well optimized code using it.. – Alexandriaalexandrian

Shouldn't modern compilers be able to optimize this when the resulting value is obviously going to be trashed anyway? – Brookebrooker

@che, yes, there should be no difference in generated code for primitive types – Mediaeval

@Brookebrooker - they do when it's a simple type, however classes that overload operator++ (such as iterators) are a different story. – Ipoh

@Scott: re: "For primitive types (int, etc) there's not much performance difference" It's safe to say that there's NO performance difference. – Positive

@che: That's a good question. The reason that C++ compilers don't replace "CustomType++;" with "++CustomType;" is because there's no guarantee that both user-defined functions have the same effect. They SHOULD...but there's no guarantee. – Positive

-1 Was operator overloading not available in C# in 2009? Pretty sure it's always been there. – Rife

@michael.bartnett: Good point, overloading ++ in C# does appear to be available. It seems though, that compared to c++, in c# you cannot overload the pre and post versions independently. So, I would assume that if the result of calling ++ in C# is not assigned to a variable or used as part of a complex expression, then the compiler would reduce the pre and post versions of ++ down to code that performs equivalently. – Annieannihilate

Wouldn't it have been great if C++ was named ++C as an indication of its confusing nature. – Dealings

@Brookebrooker Actually, if you force the compiler to apply an optimization to every for() loop in your code, you slow down the build. – Extempore

Answer 3

In C# there is no difference when used in a for loop.

for (int i = 0; i < 10; i++) { Console.WriteLine(i); }

outputs the same thing as

for (int i = 0; i < 10; ++i) { Console.WriteLine(i); }

As others have pointed out, when used in general i++ and ++i have a subtle yet significant difference:

int i = 0;
Console.WriteLine(i++);   // Prints 0
int j = 0;
Console.WriteLine(++j);   // Prints 1

i++ reads the value of i then increments it.

++i increments the value of i then reads it.

Cobelligerent

Concluding: the same post / pre increment semantics as in C++. – Coachwork

@Coachwork - not sure what your point is? I just happened to pick c# for my example. – Cobelligerent

I don't think that the first point is relevant. In a for loop (c# or not) the increment part is always executed after the body of the loop. Once executed, the variable is modified whether post or pre increment was used. – Coo

@Coo - I read the question as "does it matter whether you use i++ or ++i in a for loop". The answer is "no it does not". – Cobelligerent

@Jon B - Just a sidenote. Making links, that's all. – Coachwork

@Jon B: Oops! Sorry, my mistake ! – Coo

@JonB The order of operations in the answer is not exactly correct. Both ++i and i++ perform the same operations in the same order: create temp copy of i; increment the temp value to produce a new value (not to override the temp); store the new value in i; now if it's ++i the result returned is the new value; if it's i++ the result returned is the temp copy. More detailed answer here: https://mcmap.net/q/87822/-what-is-the-difference-between-i-and-i-in-c – Glidebomb

This is the only answer that should be accepted. The question is "Is there a difference in ++i and i++ in a for loop?". The answer is "No.". Why does each an every other answer have to go into detailed explanations about pre and post incrementing when this is not even asked? – Charles

Answer 4

The question is:

Is there a difference in ++i and i++ in a for loop?

The answer is: No.

Why does each and every other answer have to go into detailed explanations about pre and post incrementing when this is not even asked?

This for-loop:

for (int i = 0; // Initialization
     i < 5;     // Condition
     i++)       // Increment
{
   Output(i);
}

Would translate to this code without using loops:

int i = 0; // Initialization

loopStart:
if (i < 5) // Condition
{
   Output(i);

   i++ or ++i; // Increment

   goto loopStart;
}

Now does it matter if you put i++ or ++i as increment here? No it does not as the return value of the increment operation is insignificant. i will be incremented AFTER the code's execution that is inside the for loop body.

Charles

This is literally the first answer that goes right into the point. Thanks. – Ribonuclease

It's not the best answer because if the for loop is incrementing a complex object (something other than an int!) the implementation of ++x may be faster than x++... (see herbsutter.com/2013/05/13/gotw-2-solution-temporary-objects) – Oleo

Answer 5

Since you ask about the difference in a loop, i guess you mean

for(int i=0; i<10; i++) 
    ...;

In that case, you have no difference in most languages: The loop behaves the same regardless of whether you write i++ and ++i. In C++, you can write your own versions of the ++ operators, and you can define separate meanings for them, if the i is of a user defined type (your own class, for example).

The reason why it doesn't matter above is because you don't use the value of i++. Another thing is when you do

for(int i=0, a = 0; i<10; a = i++) 
    ...;

Now, there is a difference, because as others point out, i++ means increment, but evaluate to the previous value, but ++i means increment, but evaluate to i (thus it would evaluate to the new value). In the above case, a is assigned the previous value of i, while i is incremented.

Astray

In C++, it is not always possible for the compiler to avoid making the temporary, so the pre-increment form is preferred. – Autotoxin

as i write, if you have an i of user defined type, they could have different semantics. but if you use an i of primitive type, then it does not make a difference for the first loop. as this is a language agnostic question, i figured not to write too much about C++ specific stuff. – Astray

Answer 6

One (++i) is preincrement, one (i++) is postincrement. The difference is in what value is immediately returned from the expression.

// Psuedocode
int i = 0;
print i++; // Prints 0
print i; // Prints 1
int j = 0;
print ++j; // Prints 1
print j; // Prints 1

Edit: Woops, entirely ignored the loop side of things. There's no actual difference in for loops when it's the 'step' portion (for(...; ...; )), but it can come into play in other cases.

Slant

Answer 7

As this code shows (see the dissambled MSIL in the comments), the C# 3 compiler makes no distinction between i++ and ++i in a for loop. If the value of i++ or ++i were being taken, there would definitely be a difference (this was compiled in Visutal Studio 2008 / Release Build):

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace PreOrPostIncrement
{
    class Program
    {
        static int SomethingToIncrement;

        static void Main(string[] args)
        {
            PreIncrement(1000);
            PostIncrement(1000);
            Console.WriteLine("SomethingToIncrement={0}", SomethingToIncrement);
        }

        static void PreIncrement(int count)
        {
            /*
            .method private hidebysig static void  PreIncrement(int32 count) cil managed
            {
              // Code size       25 (0x19)
              .maxstack  2
              .locals init ([0] int32 i)
              IL_0000:  ldc.i4.0
              IL_0001:  stloc.0
              IL_0002:  br.s       IL_0014
              IL_0004:  ldsfld     int32 PreOrPostIncrement.Program::SomethingToIncrement
              IL_0009:  ldc.i4.1
              IL_000a:  add
              IL_000b:  stsfld     int32 PreOrPostIncrement.Program::SomethingToIncrement
              IL_0010:  ldloc.0
              IL_0011:  ldc.i4.1
              IL_0012:  add
              IL_0013:  stloc.0
              IL_0014:  ldloc.0
              IL_0015:  ldarg.0
              IL_0016:  blt.s      IL_0004
              IL_0018:  ret
            } // end of method Program::PreIncrement             
             */
            for (int i = 0; i < count; ++i)
            {
                ++SomethingToIncrement;
            }
        }

        static void PostIncrement(int count)
        {
            /*
                .method private hidebysig static void  PostIncrement(int32 count) cil managed
                {
                  // Code size       25 (0x19)
                  .maxstack  2
                  .locals init ([0] int32 i)
                  IL_0000:  ldc.i4.0
                  IL_0001:  stloc.0
                  IL_0002:  br.s       IL_0014
                  IL_0004:  ldsfld     int32 PreOrPostIncrement.Program::SomethingToIncrement
                  IL_0009:  ldc.i4.1
                  IL_000a:  add
                  IL_000b:  stsfld     int32 PreOrPostIncrement.Program::SomethingToIncrement
                  IL_0010:  ldloc.0
                  IL_0011:  ldc.i4.1
                  IL_0012:  add
                  IL_0013:  stloc.0
                  IL_0014:  ldloc.0
                  IL_0015:  ldarg.0
                  IL_0016:  blt.s      IL_0004
                  IL_0018:  ret
                } // end of method Program::PostIncrement
             */
            for (int i = 0; i < count; i++)
            {
                SomethingToIncrement++;
            }
        }
    }
}

Flew

Answer 8

Here is a Java-Sample and the Byte-Code, post- and preIncrement show no difference in Bytecode:

public class PreOrPostIncrement {

    static int somethingToIncrement = 0;

    public static void main(String[] args) {
        final int rounds = 1000;
        postIncrement(rounds);
        preIncrement(rounds);
    }

    private static void postIncrement(final int rounds) {
        for (int i = 0; i < rounds; i++) {
            somethingToIncrement++;
        }
    }

    private static void preIncrement(final int rounds) {
        for (int i = 0; i < rounds; ++i) {
            ++somethingToIncrement;
        }
    }
}

And now for the byte-code (javap -private -c PreOrPostIncrement):

public class PreOrPostIncrement extends java.lang.Object{
static int somethingToIncrement;

static {};
Code:
0:  iconst_0
1:  putstatic   #10; //Field somethingToIncrement:I
4:  return

public PreOrPostIncrement();
Code:
0:  aload_0
1:  invokespecial   #15; //Method java/lang/Object."<init>":()V
4:  return

public static void main(java.lang.String[]);
Code:
0:  sipush  1000
3:  istore_1
4:  sipush  1000
7:  invokestatic    #21; //Method postIncrement:(I)V
10: sipush  1000
13: invokestatic    #25; //Method preIncrement:(I)V
16: return

private static void postIncrement(int);
Code:
0:  iconst_0
1:  istore_1
2:  goto    16
5:  getstatic   #10; //Field somethingToIncrement:I
8:  iconst_1
9:  iadd
10: putstatic   #10; //Field somethingToIncrement:I
13: iinc    1, 1
16: iload_1
17: iload_0
18: if_icmplt   5
21: return

private static void preIncrement(int);
Code:
0:  iconst_0
1:  istore_1
2:  goto    16
5:  getstatic   #10; //Field somethingToIncrement:I
8:  iconst_1
9:  iadd
10: putstatic   #10; //Field somethingToIncrement:I
13: iinc    1, 1
16: iload_1
17: iload_0
18: if_icmplt   5
21: return

}

Criminal

Answer 9

There is no difference if you are not using the value after increment in the loop.

for (int i = 0; i < 4; ++i){
cout<<i;       
}
for (int i = 0; i < 4; i++){
cout<<i;       
}

Both the loops will print 0123.

But the difference comes when you uses the value after increment/decrement in your loop as below:

Pre Increment Loop:

for (int i = 0,k=0; i < 4; k=++i){
cout<<i<<" ";       
cout<<k<<" "; 
}

Output: 0 0 1 1 2 2 3 3

Post Increment Loop:

for (int i = 0, k=0; i < 4; k=i++){
cout<<i<<" ";       
cout<<k<<" "; 
}

Output: 0 0 1 0 2 1 3 2

I hope the difference is clear by comparing the output. Point to note here is the increment/decrement is always performed at the end of the for loop and hence the results can be explained.

Mummy

Answer 10

Yes, there is. The difference is in the return value. The return value of "++i" will be the value after incrementing i. The return of "i++" will be the value before incrementing. This means that code that looks like the following:

int a = 0;
int b = ++a; // a is incremented and the result after incrementing is saved to b.
int c = a++; // a is incremented again and the result before incremening is saved to c.

Therefore, a would be 2, and b and c would each be 1.

I could rewrite the code like this:

int a = 0; 

// ++a;
a = a + 1; // incrementing first.
b = a; // setting second. 

// a++;
c = a; // setting first. 
a = a + 1; // incrementing second. 

Legitimatize

Answer 11

There is no actual difference in both cases 'i' will be incremented by 1.

But there is a difference when you use it in an expression, for example:

int i = 1;
int a = ++i;
// i is incremented by one and then assigned to a.
// Both i and a are now 2.
int b = i++;
// i is assigned to b and then incremented by one.
// b is now 2, and i is now 3

Ebonieebonite

Answer 12

There is more to ++i and i++ than loops and performance differences. ++i returns a l-value and i++ returns an r-value. Based on this, there are many things you can do to ( ++i ) but not to ( i++ ).

1- It is illegal to take the address of post increment result. Compiler won't even allow you.
2- Only constant references to post increment can exist, i.e., of the form const T&.
3- You cannot apply another post increment or decrement to the result of i++, i.e., there is no such thing as I++++. This would be parsed as ( i ++ ) ++ which is illegal.
4- When overloading pre-/post-increment and decrement operators, programmers are encouraged to define post- increment/decrement operators like:

T& operator ++ ( )
{
   // logical increment
   return *this;
}

const T operator ++ ( int )
{
    T temp( *this );
    ++*this;
    return temp;
}

Firewarden

Answer 13

It boggles my mind why so may people write the increment expression in for-loop as i++.

In a for-loop, when the 3rd component is a simple increment statement, as in

for (i=0; i<x; i++)  

or

for (i=0; i<x; ++i)   

there is no difference in the resulting executions.

Dunno

Is it an answer, or is it a question? – Sewage

Since it doesn't matter, why would it boggle your mind whether someone wrote i++? Is there some reason why someone would prefer to write ++i? – Outspeak

Post-increment looks nicer since it matches i += 1. Incrementing and using the evaluated result in the same bit of code makes for confusing code anyway. – Softpedal

Answer 14

As @Jon B says, there is no difference in a for loop.

But in a while or do...while loop, you could find some differences if you are making a comparison with the ++i or i++

while(i++ < 10) { ... } //compare then increment

while(++i < 10) { ... } //increment then compare

Bernabernadene

two downvotes? What is wrong with what I wrote? And it is related to the question (as vague as it is). – Bernabernadene

Conditions with side-effects (changing the variable's value) are very confusing anyway. – Softpedal

Answer 15

In javascript due to the following i++ may be better to use:

var i=1;
alert(i++); // before, 1. current, 1. after, 2.
alert(i); // before, 2. current, 2. after, 2.
alert(++i); // before, 2. current, 3 after, 3.

While arrays (I think all) and some other functions and calls use 0 as a starting point you would have to set i to -1 to make the loop work with the array when using ++i.

When using i++ the following value will use the increased value. You could say i++ is the way humans count, cause you can start with a 0.

Manzoni

Answer 16

To understand what a FOR loop does

The image above shows that FOR can be converted to WHILE, as they eventually have totally the same assembly code (at least in gcc). So we can break down FOR into a couple of pieces, to undertand what it does.

for (i = 0; i < 5; ++i) {
  DoSomethingA();
  DoSomethingB();
}

is equal to the WHILE version

i = 0; //first argument (a statement) of for
while (i < 5 /*second argument (a condition) of for*/) {
  DoSomethingA();
  DoSomethingB();
  ++i; //third argument (another statement) of for
}

---

It means that you can use FOR as a simple version of WHILE:

1. The first argument of FOR (int i) is executed, outside, before the loop.

2. The third argument of FOR (i++ or ++i) is executed, inside, in the last line of the loop.

TL:DR: no matter whether i++ or ++i, we know that when they are standalone, they make no difference but +1 on themselves.

In school, they usually teach the i++ way, but there are also lots of people prefer the ++i way due to several reasons.

NOTE: In the past, i++ has very little impact on the performance, as it does not only plus one by itself, but also keeps the original value in the register. But for now, it makes no difference as the compiler makes the plus one part the same.

Hasid

The Compiler Explorer image is good, but it's much more readable as code. – Softpedal

Answer 17

There can be a difference for loops. This is the practical application of post/pre-increment.

        int i = 0;
        while(i++ <= 10) {
            Console.Write(i);
        }
        Console.Write(System.Environment.NewLine);

        i = 0;
        while(++i <= 10) {
            Console.Write(i);
        }
        Console.ReadLine();

While the first one counts to 11 and loops 11 times, the second does not.

Mostly this is rather used in a simple while(x-- > 0 ) ; - - Loop to iterate for example all elements of an array (exempting foreach-constructs here).

Backwater

Answer 18

Yes, there is a difference between ++i and i++ in a for loop, though in unusual use cases; when a loop variable with increment/decrement operator is used in the for block or within the loop test expression, or with one of the loop variables. No it is not simply a syntax thing.

As i in a code means evaluate the expression i and the operator does not mean an evaluation but just an operation;

• ++i means increment value of i by 1 and later evaluate i,
• i++ means evaluate i and later increment value of i by 1.

So, what are obtained from each two expressions differ because what is evaluated differs in each. All same for --i and i--

For example;

let i = 0

i++ // evaluates to value of i, means evaluates to 0, later increments i by 1, i is now 1
0
i
1
++i // increments i by 1, i is now 2, later evaluates to value of i, means evaluates to 2
2
i
2

In unusual use cases, however next example sounds useful or not does not matter, it shows a difference

for(i=0, j=i; i<10; j=++i){
    console.log(j, i)
}

for(i=0, j=i; i<10; j=i++){
    console.log(j, i)
}

Highgrade

What does this add over existing answers? – Hundredfold

it answers more directly what is asked than the answers I have read. – Vadnais

Answer 19

In certain situations ++i and i+1 might give different results, same goes for --i, i - 1 etc.

This is not because there is a flaw in how increment and decrement operators work but because of a little fact sometimes overlooked by new programmers.

As a rule of thumb do not use inc/dec inside array's square brackets. For example, I won't do something like arr[++i] in place of arr[i + 1]. Though both would get us the same value of i, there is something that we overlooked here.

If a loop condition is based on i's value for execution then replacing arr[i + 1] with arr[++i] would result in error. Why?

Let say i = 5, then arr[i + 1] would mean arr[6] and arr[++i] although would mean arr[6] but would also change the value of i to 6 and this might not be something that we want to do. We might not want to change the value of i but due to a simple ++/-- operator, we changed the value.

So be careful when using ++/-- operators.

I hope, I was able to make my point easy for understanding.

Rorqual

Answer 20

the answer of differences between ++i and i++ as a single statement depends on your compiler and your memory constraints (e.g. embedded).

Old compiler would generate extra assembler code to store the additional value a the return value of i++, thus need more memory for no gain.

Nowadays the optimising compilers will usually generate the same assembler code with a single increment operation.

Cheers

Windward

As has been pointed out several times, the question is about the difference of those expressions in a (for) loop. – Fist

And that's the answer to that. Because ++i in a loop is not a compound statement like b = a[i++]. It is a single statement with no side effect. – Windward

Answer 21

For i's of user-defined types, these operators could (but should not) have meaningfully different sematics in the context of a loop index, and this could (but should not) affect the behavior of the loop described.

Also, in c++ it is generally safest to use the pre-increment form (++i) because it is more easily optimized. (Scott Langham beat me to this tidbit. Curse you, Scott)

Teenyweeny

The semantics of postfix are supposed to be bigger than prefix. -1 – Coachwork

Answer 22

I dont know for the other languages but in Java ++i is a prefix increment which means: increase i by 1 and then use the new value of i in the expression in which i resides, and i++ is a postfix increment which means the following: use the current value of i in the expression and then increase it by 1. Example:

public static void main(String [] args){

    int a = 3;
    int b = 5;
    System.out.println(++a);
    System.out.println(b++);
    System.out.println(b);

} and the output is:

• 4
• 5
• 6

Maidstone

Answer 23

i++ ; ++i ; both are similar as they are not used in an expression.

class A {

     public static void main (String []args) {

     int j = 0 ;
     int k = 0 ;
     ++j;
     k++;
    System.out.println(k+" "+j);

}}

prints out :  1 1

Rayborn