使用此复合形式时，为什么用XOR交换值失败？

我发现此代码使用XOR^运算符在不使用第三个变量的情况下交换了两个数字。

码：

int i = 25;
int j = 36;
j ^= i;       
i ^= j;
j ^= i;

Console.WriteLine("i:" + i + " j:" + j);

//numbers Swapped correctly
//Output: i:36 j:25

现在，我将上面的代码更改为该等效代码。

我的代码：

int i = 25;
int j = 36;

j ^= i ^= j ^= i;   // I have changed to this equivalent (???).

Console.WriteLine("i:" + i + " j:" + j);

//Not Swapped correctly            
//Output: i:36 j:0

现在，我想知道为什么我的代码输出错误？

编辑：好的，知道了。

首先要说明的是，显然您不应该使用此代码。但是，当您展开它时，它等效于：

j = j ^ (i = i ^ (j = j ^ i));

（如果使用的是更复杂的表达式，例如foo.bar++ ^= i，则++仅对进行一次评估就很重要，但在这里我相信它会更简单。）

现在，操作数的求值顺序始终是从左到右，因此首先我们得到：

j = 36 ^ (i = i ^ (j = j ^ i));

这是最重要的步骤。我们最后得到了36作为最后执行的XOR操作的LHS。LHS不是“ jRHS评估后的值”。

^的RHS的评估涉及“一级嵌套”表达式，因此变为：

j = 36 ^ (i = 25 ^ (j = j ^ i));

然后查看最深层的嵌套，我们可以同时替换i和j：

j = 36 ^ (i = 25 ^ (j = 25 ^ 36));

...变成

j = 36 ^ (i = 25 ^ (j = 61));

jRHS中的分配首先发生，但是无论如何最后都会覆盖结果，因此我们可以忽略这一点-j在最终分配之前没有进一步的评估：

j = 36 ^ (i = 25 ^ 61);

现在等于：

i = 25 ^ 61;
j = 36 ^ (i = 25 ^ 61);

要么：

i = 36;
j = 36 ^ 36;

变成：

i = 36;
j = 0;

我认为这都是正确的，并且可以找到正确的答案...如果有关评估顺序的某些细节略有偏离，对Eric Lippert表示歉意:(

检查生成的IL，并给出不同的结果；

正确的交换可以直接产生：

IL_0001:  ldc.i4.s   25
IL_0003:  stloc.0        //create a integer variable 25 at position 0
IL_0004:  ldc.i4.s   36
IL_0006:  stloc.1        //create a integer variable 36 at position 1
IL_0007:  ldloc.1        //push variable at position 1 [36]
IL_0008:  ldloc.0        //push variable at position 0 [25]
IL_0009:  xor           
IL_000a:  stloc.1        //store result in location 1 [61]
IL_000b:  ldloc.0        //push 25
IL_000c:  ldloc.1        //push 61
IL_000d:  xor 
IL_000e:  stloc.0        //store result in location 0 [36]
IL_000f:  ldloc.1        //push 61
IL_0010:  ldloc.0        //push 36
IL_0011:  xor
IL_0012:  stloc.1        //store result in location 1 [25]

错误的交换会生成以下代码：

IL_0001:  ldc.i4.s   25
IL_0003:  stloc.0        //create a integer variable 25 at position 0
IL_0004:  ldc.i4.s   36
IL_0006:  stloc.1        //create a integer variable 36 at position 1
IL_0007:  ldloc.1        //push 36 on stack (stack is 36)
IL_0008:  ldloc.0        //push 25 on stack (stack is 36-25)
IL_0009:  ldloc.1        //push 36 on stack (stack is 36-25-36)
IL_000a:  ldloc.0        //push 25 on stack (stack is 36-25-36-25)
IL_000b:  xor            //stack is 36-25-61
IL_000c:  dup            //stack is 36-25-61-61
IL_000d:  stloc.1        //store 61 into position 1, stack is 36-25-61
IL_000e:  xor            //stack is 36-36
IL_000f:  dup            //stack is 36-36-36
IL_0010:  stloc.0        //store 36 into positon 0, stack is 36-36 
IL_0011:  xor            //stack is 0, as the original 36 (instead of the new 61) is xor-ed)
IL_0012:  stloc.1        //store 0 into position 1

显然，第二种方法生成的代码是不正确的，因为j的旧值用于需要新值的计算中。

C＃负载j，i，j，i栈，并且每个存储关于XOR结果，而不更新堆栈，所以最左边的XOR用途的初始值j。

改写：

j ^= i;       
i ^= j;
j ^= i;

扩展中^=：

j = j ^ i;       
i = j ^ i;
j = j ^ i;

替代：

j = j ^ i;       
j = j ^ (i = j ^ i);

仅当/因为首先对^运算符的左侧求值时，才可以替换它：

j = (j = j ^ i) ^ (i = i ^ j);

崩溃^：

j = (j ^= i) ^ (i ^= j);

对称地：

i = (i ^= j) ^ (j ^= i);