Why is C# skipping the post increment ( ++ ) operator in my code but not C++?

[ArinoLane]

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

output : 2 4 8 16 32

but when i run the same code in C/C++ i get this,

  int x = 1;
  for (int i = 0; i < 5; i++) 
   {
    x += x++;
    std::cout << x;
   }

Output: 3 7 15 31 63

It looks like C# is ignoring to do X++ at the end where c++ does the post increment.

[bernd5]

x += x++; is the same as x = x + x++;

In CSharp we evaluate always from left to right - first x, than x++;

So x is first 1.
x++ is evaluated to 1, too (it is the post increment operator).
After the evaluation x is incremented by one and assigned to x.

The right hand side of x = x + x++ is evaluated to 1 +1 which is 2.
After the evaluation of the right hand side - the result is assigned to x....
The side effect of evaluating x++ is lost.

---

In C++ a compiler can evaluate from left to right or from right to left - there we have no strict eval order. This is why your code is UB (undefined behaviour) in C++.

See: https://godbolt.org/z/YjTx9E1nE

When we evaluate from right to left we start with x++ which is evaluated to 1. But it has a side effect and increments x by one.
After that we evaluate x which is now 2. So we get 3...

---

To get the intended result you can write:

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

or

using System;

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

or

using System;

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

or

using System;

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

[jilles-sg]

Although this isn't a C/C++ forum...

In C++ a compiler can evaluate from left to right or from right to left - there we have no strict eval order. This is why your code is UB (undefined behaviour) in C++.

This is not actually the case. From C++17 on, assignment operators first evaluate their right operand and then their left operand. So x += x++; is fully defined and the same as x += x + 1;. However, x = x + x++; is still undefined because in x + x++ the side effect of incrementing x is not properly sequenced with respect to the read of x in the other operand (there is a specific rule that says this is undefined behaviour; keyword: "sequence point").

In C, and in C++ before C++17, assignment operators do not impose such sequencing so x += x++; runs into similar undefined behaviour.

Where this might be useful to a compiler is that if you write obj1->field + obj2->field++ it can conclude that obj1 and obj2 point to different objects.