В чем разница между X = X ++; против X ++ ;?

Question

Вы когда-нибудь пробовали это раньше?

static void Main(string[] args)
{
    int x = 10;
    x = x++;
    Console.WriteLine(x);
}

Выход: 10.

но для

static void Main(string[] args)
{
    int x = 10;
    x++;
    Console.WriteLine(x);
}

Выход: 11.

Кто-нибудь может объяснить, почему это так?

Answer 1

Возможно, я не прав, но мне легче понять результат на похожем примере:

public static void main(String[] args) {
    int x = 10;
    int y = 0;
    y = x + x++;  //1, 2, 3, 4
    x += x;       //5
    System.out.println("x = " + x + "; y = " + y);  //6
}

Давайте посмотрим на операцию y = x + x ++, шаг за шагом:

1. Компьютер принимает значение x и добавляет его к значению x (10 + 10 = 20)
2. Компьютер ПРЕДСТАВЛЯЕТ РЕЗУЛЬТАТ ВРЕМЕННОЙ ПЕРЕМЕННОЙ (temp = 20)
3. Копутер увеличивает x (10 + 1 = 11)
4. Компьютер НАЗНАЧАЕТ РУСУЛЬТ РАБОТЫ ПРАВЫЙ СТОРОНЫ, ХРАНЕННЫЙ В ТЕМПЕРАТУРЕ y (20)
5. Компьютер принимает значение x и добавляет его к значению x (11 + 11 = 22)
6. Окончательный результат: x = 22; у = 20

А теперь давайте вернемся к нашему примеру и сделаем те же шаги:

public static void main(String[] args) {
    int x = 10;
    x = x++; //1, 2, 3, 4
    System.out.println(x);  //5
}

1. Компьютер принимает значение х (10)
2. Компьютер ПРЕДСТАВЛЯЕТ РЕЗУЛЬТАТ ВРЕМЕННОЙ ПЕРЕМЕННОЙ (temp = 10)
3. Копутер увеличивает x (10 + 1 = 11)
4. Компьютер НАЗНАЧАЕТ РУСУЛЬТ РАБОТЫ ПРАВЫЙ СТОРОНЫ, ХРАНЕННЫЙ В ТЕМПЕРАТУРЕ Х Х
5. Окончательный результат: x = 10

Answer 2

Простое объяснение:

x ++ - постфиксный инкремент.

Что делает компилятор:

а) Присвойте значение х х б) Увеличьте временное значение x (я думаю, оно может быть даже оптимизировано) в) выбросить временное значение х

Если вы хотите, чтобы код возвращал 11 с присваиванием, напишите:

x = ++ x;

Answer 3

Установка оператора приращения после переменной означает, что приращение и присваивание происходит после выражение вычисляется ... так Исходное утверждение х = х ++; переводит на 1. Оценить х и сохранить значение в тираной памяти ... Теперь выполните код, вызванный оператором ++ .... (шаги 2 и 3) 2. Увеличение значения х (в переходной памяти) 3. Присвойте Увеличенное значение месту хранения x ... Теперь продолжаем выполнение остальной части строки, слева есть знак = ... 5. Таким образом, присвойте значение, сохраненное на шаге 1 (необязательное значение), выражению слева от знака =, которое равно x

Answer 4

Попробуйте вызвать ++ x и посмотреть, работает ли это.

Answer 5

В качестве отдельного оператора, x++; является как приращением, так и присваиванием. Кажется, что есть некоторые сомнения относительно того, что происходит, когда. Если у нас есть

int x = 10;
int y = (x++) + 2;

Мы получим x = 11 и y = 12. Присвоено текущее значение x, и , затем происходит приращение и переназначение x. Итак, при использовании той же переменной,

int x = 10; // Create a variable x, and assign an initial value of 10.
x = x++;    // First, assign the current value of x to x. (x = x)
            // Second, increment x by one. (x++ - first part)
            // Third, assign the new value of x to x. (x++ - second part)

Как ни крути, новое значение x равно 11.

Я был совершенно неправ в этом.

Answer 6

Результат выполнения задания

x = x++;

не определено в C и C ++ , и я думаю, то же самое можно сказать и о C #.

Таким образом, фактическая последовательность операций, которая происходит, зависит от того, как компилятор решит ее реализовать, нет никакой гарантии, будет ли сначала назначаться или увеличиваться. (это хорошо определено в C #, как указал Джон Скит в комментариях. Хотя сейчас я чувствую, что этот ответ имеет гораздо меньшую ценность, я оставляю этот пост без ответа для вопроса ОП и его ответа в комментарии.)

Однако, в этом случае, появляется последовательность операций, которая происходит так:

1. старое значение (10) из x сохраняется
2. x увеличивается для части ++
3. старое значение теперь присваивается х для присвоения

Таким образом, хотя приращение происходит, оно заменяется присваиванием со старым значением, таким образом, сохраняя x равным 10.

НТН