Post-increment within a self-assignment

by

Let’s take a look at the intermediary language code for that:

IL_0000:  nop
IL_0001:  ldc.i4.s    2A
IL_0003:  stloc.0     // c
IL_0004:  ldloc.0     // c

This loads the constant integer 42 onto the stack, then stores it into the variable c, and loads it immediately again onto the stack.

IL_0005:  stloc.1
IL_0006:  ldloc.1

This copies the value into another register, and also loads it again.

IL_0007:  ldc.i4.1
IL_0008:  add

This adds the constant 1 to the loaded value

IL_0009:  stloc.0     // c

… and stores the result (43) into the variable c.

IL_000A:  ldloc.1
IL_000B:  stloc.0     // c

Then the value from the other register is loaded (that’s still 42!) and stored into the variable c.

IL_000C:  ldloc.0     // c
IL_000D:  call        System.Console.WriteLine
IL_0012:  nop
IL_0013:  ret

Then the value (42) is loaded from the variable, and printed.

So what you can see from this is that while c++ increments the variable by one after the result was returned, that incrementing happens still before assinging the value to the variable. So the sequence is more like this:

  1. Get value from c
  2. Post-increment c
  3. Assign previously read value to c

And that should explain why you get that result 🙂

To add one more example, since this was mentioned in a comment that was since deleted:

c = c++ + c;

This works very similarly: Assuming an initial value of 2 again, the left side of the addition is evaluated first. So the value is read from the variable (2), then c is incremented (c becomes 3). Then the right side of the addition is evaluated. The value of c is read (now 3). Then the addition takes place (2 + 3) and the result (5) is assigned to the variable.

The takeaway from this is that you should avoid mixing increment and decrement operations in normal expressions. While the behavior is very well defined and makes absolute sense (as shown above), it is still sometimes difficult to wrap your head around it. Especially when you assign something to the same variable that you increment in the expression, this becomes confusing quickly. So do yourself and others a favor and avoid increment/decrement operations when they are not completely on their own 🙂

More Related Contents:

  1. Pre- & Post Increment in C#
  2. C: What is the output of the following code? And please explain [duplicate]
  3. What is the difference between ++i and i++?
  4. Is there a performance difference between i++ and ++i in C++?
  5. Post-increment and Pre-increment concept?
  6. Is there a performance difference between i++ and ++i in C?
  7. Incrementing in C++ – When to use x++ or ++x?
  8. What is more efficient, i++ or ++i? [duplicate]
  9. Pre increment vs Post increment in array
  10. Output of multiple post and pre increments in one statement [duplicate]
  11. Order of operations for pre-increment and post-increment in a function argument? [duplicate]
  12. ++i or i++ in for loops ?? [duplicate]
  13. Select Tag Helper in ASP.NET Core MVC
  14. List or IList [closed]
  15. XML serialization of interface property
  16. How to save a List on Settings.Default?
  17. Escape invalid XML characters in C#
  18. What is the fastest way to create a checksum for large files in C#
  19. WebAPI StreamContent vs PushStreamContent
  20. Alternate property name while deserializing
  21. Parse and modify a query string in .NET Core
  22. Should we always include a default constructor in the class?
  23. Please explain why I am able to instantiate the “Application” interface in Excel VSTO
  24. ToArrayAsync() throws “The source IQueryable doesn’t implement IAsyncEnumerable”
  25. Cannot debug Blazor wasm
  26. MoveNext instead of actual method/task name
  27. What is difference between RegAsm.exe and regsvr32? How to generate a tlb file using regsvr32?
  28. Print html document from Windows Service in C# without print dialog
  29. C#: How to make Sieve of Atkin incremental
  30. Decompressing password-protected ZIP files with .NET 4.5

Leave a Comment