Индекс, присвоение и инкремент в одном операторе ведут себя по-другому в C++ и C#. Почему?

Your C++ code could, in fact, do anything. arr[index] = ++index; invokes undefined behaviour.

The behaviour of using index and ++index inside the same assignment is unspecified in C++. You just can't just do that: write arr[index] = index + 1 and increment your variable after that. For that matter, with my C++ compiler on my machine I see arr[0] = 1, and arr[1] is untouched.

In the case of C++, at least, you're invoking undefined behavior by preincrementing and using index without a sequence point in between. If you feed that code to GCC with warnings enabled it will say:

preinc.cpp:6: warning: operation on ‘index’ may be undefined

I'm guessing that it's undefined as well in C#, but I don't know the language. For C and C++ at the very least though, the answer is that the compiler can do anything it wants without being wrong because your code is erroneous. There's no obligation for different compilers (or even the same compiler) to produce consistent results, either.

Note: Acording to @Eric Lippert's answer, the behavior is strictly defined for C#, so let me reword my answer on this.

This code:

arr[index] = ++index;

Is hard to read even if the C# compiler knows exactly how to evaluate it and in which order. For this reason alone it should be avoided.

The MSDN page on C# Operators goes so far as pointing out that this behaviour might be undefined, even though Eric points out it is not. The fact that multiple sources of documentation (I'll trust Eric on this however) gets it different is also a tell that this might be something best left alone.

The result of the C++ version will not always be as you write as you are invoking undefined behaviour. In C++ you will get undefined behaviour if you use the value of a variable in an expression when that variable is also modified the same expression unless reading that value is part of determining the value to be written, or the expression contains a sequence point between the read and the write.

In your expression, you are reading the value of index to determine where to assign the result of the right hand side of the =, but the right hand sub-expression also modifies index.

индекс в C # является типом значения, что означает, что вы возвращаете новый экземпляр значения, когда выполняете с ним операции.

Если вы представляете его как процедуру вместо оператора, процедура будет выглядеть так:

public int Increment(int value)
{
   int returnValue=value+1;
   return returnValue;
}

C ++, однако, работает со ссылкой на объект, поэтому процедура будет выглядеть так:

int Increment(int &value)
{
   value=value+1;
   return value;
}

Примечание: если вы применяли оператор к объекту (скажем, перегружали ++ оператор), то C # будет вести себя как C ++, поскольку типы объектов передаются как ссылки.