Чому обмін значеннями з 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

Тепер я хочу знати, чому мій код дає неправильний вивід?

EDIT: Гаразд, зрозумів.

Перше, що слід сказати, це те, що очевидно, ви все одно не повинні використовувати цей код. Однак, коли ви розширюєте її, вона стає еквівалентною:

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

(Якби ми використовували більш складний вираз, такий як foo.bar++ ^= i, було б важливо, щоб його ++оцінювали лише один раз, але тут я вважаю, що це простіше.)

Тепер порядок оцінки операндів завжди зліва направо, тому для початку отримаємо:

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

Це (вище) є найважливішим кроком. Ми отримали 36 як LHS для операції XOR, яка виконується останньою. LHS не є "значенням jпісля оцінки RHS".

Оцінка RHS значення ^ включає вираз «вкладений на один рівень», тому воно стає:

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

Потім, дивлячись на найглибший рівень вкладеності, ми можемо підставити обидва iі j:

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

... що стає

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

Присвоєння jв RHS відбувається спочатку, але результат у будь-якому випадку перезаписується в кінці, тому ми можемо проігнорувати це - немає подальших оцінок jдо остаточного призначення:

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

Зараз це еквівалентно:

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

Або:

i = 36;
j = 36 ^ 36;

Що стає:

i = 36;
j = 0;

Я думаю, що це все правильно, і це діходить до правильної відповіді ... вибачення перед Еріком Ліппертом, якщо деякі деталі щодо замовлення на оцінку трохи не відповідають

Перевірив сформований ІЛ і він видає різні результати;

Правильний обмін генерує простий:

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);