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

User · Answer

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

User · Answer

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

User · Answer

They both increment the number    i is equivalent to i   i   1   i   and   i are very similar but not exactly the same  Both increment the number  but   i increments the number before the current expression is evaluated  whereas i   increments the number after the expression is evaluated   int i   3  int a   i       a   3  i   4 int b     a     b   4  a      Check this link

User · Answer

There can be a difference for loops  This is the practical application of post pre-increment                       int i   0          while i    lt   10                Console Write i                     Console Write System Environment NewLine            i   0          while   i  lt   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

User · Answer

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 lt 10  j   i       console log j  i     for i 0  j i  i lt 10  j i         console log j  i

User · Answer

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  lt  5  i      Console Write i    Console WriteLine      for  int i   0  i  lt  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  lt  5  n   i

User · Answer

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

User · Answer

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 lt x  i        or   for  i 0  i lt x    i       there is no difference in the resulting executions

User · Answer

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  lt  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  lt  count  i                                  SomethingToIncrement

User · Answer

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 amp   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 amp  operator                logical increment    return  this     const T operator      int         T temp   this           this      return temp

User · Answer

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

User · Answer

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

User · Answer

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

User · Answer

In C  there is no difference when used in a for loop   for  int i   0  i  lt  10  i      Console WriteLine i       outputs the same thing as   for  int i   0  i  lt  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

User · Answer

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  lt  rounds  i                  somethingToIncrement                         private static void preIncrement final int rounds            for  int i   0  i  lt  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   lt init gt     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

User · Answer

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  lt  5         Condition      i             Increment      Output i       Would translate to this code without using loops   int i   0     Initialization  loopStart  if  i  lt  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

User · Answer

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  lt  5         Condition      i             Increment      Output i       Would translate to this code without using loops   int i   0     Initialization  loopStart  if  i  lt  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

User · Answer

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

User · Answer

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

User · Answer

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    lt  10            compare then increment  while   i  lt  10            increment then compare

User · Answer

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  lt  5  i      Console Write i    Console WriteLine      for  int i   0  i  lt  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  lt  5  n   i

User · Answer

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    lt  10            compare then increment  while   i  lt  10            increment then compare

User · Answer

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

User · Answer

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

User · Answer

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  lt  5    i      DoSomethingA      DoSomethingB       is equal to the WHILE version i   0    first argument  a statement  of for while  i  lt  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   The first argument of FOR  int i  is executed  outside  before the loop   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

User · Answer

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

User · Answer

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  lt  rounds  i                  somethingToIncrement                         private static void preIncrement final int rounds            for  int i   0  i  lt  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   lt init gt     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

User · Answer

Since you ask about the difference in a loop  i guess you mean  for int i 0  i lt 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 lt 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

User · Answer

Since you ask about the difference in a loop  i guess you mean  for int i 0  i lt 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 lt 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

User · Answer

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

User · Answer

They both increment the number    i is equivalent to i   i   1   i   and   i are very similar but not exactly the same  Both increment the number  but   i increments the number before the current expression is evaluated  whereas i   increments the number after the expression is evaluated   int i   3  int a   i       a   3  i   4 int b     a     b   4  a      Check this link

User · Answer

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 lt x  i        or   for  i 0  i lt x    i       there is no difference in the resulting executions

User · Answer

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    lt  10            compare then increment  while   i  lt  10            increment then compare

User · Answer

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  lt  5    i      DoSomethingA      DoSomethingB       is equal to the WHILE version i   0    first argument  a statement  of for while  i  lt  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   The first argument of FOR  int i  is executed  outside  before the loop   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

User · Answer

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

User · Answer

Since you ask about the difference in a loop  i guess you mean  for int i 0  i lt 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 lt 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

User · Answer

In C  there is no difference when used in a for loop   for  int i   0  i  lt  10  i      Console WriteLine i       outputs the same thing as   for  int i   0  i  lt  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

User · Answer

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  lt  rounds  i                  somethingToIncrement                         private static void preIncrement final int rounds            for  int i   0  i  lt  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   lt init gt     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

User · Answer

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  lt  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  lt  count  i                                  SomethingToIncrement

User · Answer

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 lt 10  j   i       console log j  i     for i 0  j i  i lt 10  j i         console log j  i

User · Answer

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  lt  rounds  i                  somethingToIncrement                         private static void preIncrement final int rounds            for  int i   0  i  lt  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   lt init gt     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

User · Answer

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

User · Answer

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

User · Answer

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

User · Answer

In C  there is no difference when used in a for loop   for  int i   0  i  lt  10  i      Console WriteLine i       outputs the same thing as   for  int i   0  i  lt  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

User · Answer

There can be a difference for loops  This is the practical application of post pre-increment                       int i   0          while i    lt   10                Console Write i                     Console Write System Environment NewLine            i   0          while   i  lt   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

User · Answer

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  lt  5  i      Console Write i    Console WriteLine      for  int i   0  i  lt  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  lt  5  n   i

User · Answer

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

User · Answer

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

User · Answer

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

User · Answer

There is no difference if you are not using the value after increment in the loop   for  int i   0  i  lt  4    i   cout lt  lt i           for  int i   0  i  lt  4  i     cout lt  lt 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  lt  4  k   i   cout lt  lt i lt  lt             cout lt  lt k lt  lt           Output   0 0 1 1 2 2 3 3  Post Increment Loop   for  int i   0  k 0  i  lt  4  k i     cout lt  lt i lt  lt             cout lt  lt k lt  lt           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

User · Answer

There can be a difference for loops  This is the practical application of post pre-increment                       int i   0          while i    lt   10                Console Write i                     Console Write System Environment NewLine            i   0          while   i  lt   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

User · Answer

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

User · Answer

In C  there is no difference when used in a for loop   for  int i   0  i  lt  10  i      Console WriteLine i       outputs the same thing as   for  int i   0  i  lt  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

User · Answer

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 amp   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 amp  operator                logical increment    return  this     const T operator      int         T temp   this           this      return temp

User · Answer

Since you ask about the difference in a loop  i guess you mean  for int i 0  i lt 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 lt 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

User · Answer

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

User · Answer

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  lt  5  i      Console Write i    Console WriteLine      for  int i   0  i  lt  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  lt  5  n   i

User · Answer

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

User · Answer

There is no difference if you are not using the value after increment in the loop   for  int i   0  i  lt  4    i   cout lt  lt i           for  int i   0  i  lt  4  i     cout lt  lt 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  lt  4  k   i   cout lt  lt i lt  lt             cout lt  lt k lt  lt           Output   0 0 1 1 2 2 3 3  Post Increment Loop   for  int i   0  k 0  i  lt  4  k i     cout lt  lt i lt  lt             cout lt  lt k lt  lt           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

User · Answer

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

User · Answer

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

User · Answer

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  lt  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  lt  count  i                                  SomethingToIncrement

User · Answer

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 amp   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 amp  operator                logical increment    return  this     const T operator      int         T temp   this           this      return temp

User · Answer

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

User · Answer

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

User · Answer

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

User · Answer

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

User · Answer

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  lt  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  lt  count  i                                  SomethingToIncrement

User · Answer

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    lt  10            compare then increment  while   i  lt  10            increment then compare

User · Answer

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 amp   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 amp  operator                logical increment    return  this     const T operator      int         T temp   this           this      return temp

User · Answer

There can be a difference for loops  This is the practical application of post pre-increment                       int i   0          while i    lt   10                Console Write i                     Console Write System Environment NewLine            i   0          while   i  lt   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

[for-loop] Difference between pre-increment and post-increment in a loop?

Examples related to for-loop

Examples related to language-agnostic

Examples related to post-increment

Examples related to pre-increment