@Владимир В

Всем известен способ обмена двух чисел без третьей переменной в языке С++ :

int x = 352;
int y =784;

x ^= y ^= x ^= y;

В C# этот метод почему-то не работает, хотя срабатывает следующее :

x ^= y;
y ^= x;
x ^= y;

В C# x ^= y ^= x ^= y; приводит к тому, что x действительно попадает на место y, но х - обнуляется.
Как это можно понять?

0

@kolorotur

В шарпе параметры выражения высчитываются слева направо.
При присваивании сначала высчитывается значение левой части оператора, потом — правой. А потом происходит присваивание.
Выполнение данного кода будет таким:
x ^= (y ^= (x ^= y))
Допустим, х = 2, у = 1, получается:

2 ^= (1 ^= (2 ^= 1))

2 ^= (1 ^= (3)) <-- x=3
2 ^= (2) <-- y=2
2 ^= 2 == 0 <-- x=0.

0

@Владимир В

В шарпе параметры выражения высчитываются слева направо?!
==================================================
Что значит параметры? Как в С++, так и в С#, выражения высчитываются СПРАВА НАЛЕВО.
Это, кстати, и показано в Вашем примере : x ^= (y ^= (x ^= y)).
Именно так, как и в С++. Так что получиться в конце должно y=2 и x=1.
Так в С++ и выходит. Так должно быть и в С# :

x ^= (y ^= (x ^= y))

Допустим, х = 2, у = 1, получается :

1) x^=y =>
x = x^y = 2 ^ 1 = 3 => теперь x=3, y=1, значение выражения (x ^= y) есть 3, пока все верно
2) y ^= (x ^= y) =>
y ^= 3 =>
y = y^3 = 1 ^ 3 = 2 => теперь y=2, x=3, значение выражения (y ^= (x ^= y)) есть 2, пока все верно
3) x ^= (y ^= (x ^= y)) =>
x ^=2 =>
x = x^2 = 3 ^ 2 = 1 => теперь y=2, x=1, так и должно быть

Но тем не менее в моей Студии получается y=2 и x=0.

0

@kolorotur

Значения, используемые в операциях.

Что-что?
В плюсах порядок вычисления значений параметров вообще не определен, то есть отдан на откуп компиляторам.
В шарпе порядок строго определен спецификацией языка: слева направо.


Уберите из моего примера укороченные операторы:
x = (x ^ (y = y ^ (x = x ^ y)));
x = (2 ^ (y = 1 ^ (x = 2 ^ 1)));
x = (2 ^ (y = 1 ^ (x = 3)));
x = (2 ^ (y = 1 ^ 3));
x = (2 ^ (y = 2));
x = 2 ^ 2
x = 0

Хоть на третьем шаге значение х присвоено 3, первый аргумент после первого знака равенства все равно остается двойка, потому как значение переменной уже вычислено.

Справа налево в моем примере получается только из-за вложенных присваиваний, но значения операторов, обратите внимание, вычислены слева направо — двойка после первого знака равенства уже стоит на своем месте.

Кому должно-то?
И почему?

Всё верно получается.

0

Psilon

Владимир В, потому что на последнем этапе в последовательном коде будет 3^2, а в однострочном - 2^2. Потому что на первом и третьем месте стоит один и тот же х. В последовательном варианте икс на первом месте обновится до трех, а в однострочном - нет.

0

@Владимир В

Уберите из моего примера укороченные операторы:
========================================
x = (x ^ (y = y ^ (x = x ^ y)));
x = (2 ^ (y = 1 ^ (x = 2 ^ 1)));
x = (2 ^ (y = 1 ^ (x = 3)));
x = (2 ^ (y = 1 ^ 3));
x = (2 ^ (y = 2));
x = 2 ^ 2
x = 0

Хорошо. Я понял, что предполагал неправильно, будто
x = (x ^ (y = y ^ (x = x ^ y)));

равносильно последовательному выполнению со сменой после каждого шага новых значений x и y :

x = x ^ y;
y = y ^ x;
x = x ^ y;

Но получается, что СРАЗУ ЖЕ выражение
x = (x ^ (y = y ^ (x = x ^ y)));
УЖЕ содержит не ПЕРЕМЕННЫЕ, а ПОСТОЯННЫЕ 2 и 1 в соответствующих местах :
x = (2 ^ (y = 1 ^ (x = 2 ^ 1)));

Верно ли тогда то, что в С++ так не делается, а делается именно так, как я предполагал первоначально,
а потому в С++ конструкция x ^= y ^= x ^= y; и дает желаемый результат?

Ну а по поводу "кому должно-то? И почему?" - я полагал, что в компиляции элементарных конструкций
типа x ^=y ^= x ^= y; в С++ и С# все сделано идентично

0

@kolorotur

Выражение содержит не постоянные, а значения переменных, которые высчитываются сразу для всего выражения, слева направо.

Для каких-то компиляторов — верно, для каких-то — нет.
Порядок вычисления операндов в стандарте С++ указан как неопределенный, значит каждая реализация компилятора может делать что пожелает.
В результате эта строчка, скомпилированная на одном компиляторе, выдаст такой же ответ, как у вас. На другом компиляторе — такой же ответ, как получается в шарпе. На третьем — вообще что-нибудь другое.
В шарпе с этим делом строго, потому любая реализация компилятора, следующая спецификации, выдаст результат 0.

Там, если копнуть, идентичности меньше, чем различий

1

@Владимир В

Значит, строго говоря, пример для С++ x ^= y ^= x ^= y; как образец обмена между переменными следует вообще признать некорректным ?

0

Psilon

Владимир В, да, т.к. это UB.
Еще пример

0

@kolorotur

Так точно.
А вот в шарпе, учитывая строгий порядок вычисления операндов, это можно сделать в одну строчку и работать будет на любом компиляторе:
И читается, как мне кажется, лучше.

0