В чем разница между 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

X ++ будет увеличивать значение, но затем возвращать его старое значение.

Так что в этом случае:

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

У вас есть X на 11 только на мгновение, затем он возвращается к 10, потому что 10 является возвращаемым значением (x ++).

Вместо этого вы можете сделать это для того же результата:

static int plusplus(ref int x)
{
  int xOld = x;
  x++;
  return xOld;
}

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

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

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

Answer 2

В присваивании x = x++ вы сначала извлекаете старое значение x для использования при оценке выражения правой части, в данном случае 'x'; затем вы увеличиваете x на 1. Наконец, вы присваиваете результаты оценки выражения (10) для x с помощью оператора присваивания.

Возможно, эквивалентный код прояснит ситуацию:

var tmp = x;
x++;
x = tmp;

Это эквивалент вашего x = x++ кода в C #.

Answer 3

Поведение x ++ - увеличивать x, но возвращать значение до приращения. По этой причине его называют пост приращением.

Итак, х = х ++; Проще говоря, будет

1. вернуть значение , затем

2. приращение х , затем

3. присвойте исходное значение (возвращаемое на шаге 1) x x .

Answer 4

x = 10
x = ++x 

x будет равно 11.

Answer 5

x++;

выполняет следующие действия:

int returnValue = x;
x = x+1;
return returnValue;

Как видите, исходное значение сохраняется, x увеличивается, а затем возвращается исходное значение.

То, что это в конечном итоге делает, - это где-то сохранить значение 10, установить x равным 11, а затем вернуть 10, что приводит к тому, что x возвращается в 10. Обратите внимание, что x действительно становится 11 для нескольких циклов (при условии оптимизация компилятора).

Answer 6

Это не ответ на вопрос напрямую, но почему в мире кто-то использовал бы

x = x++;

Полностью игнорирует назначение оператора постинкрементного / предварительного инкремента.

Answer 7

Вы можете думать об этом так:

int x = 10;

X является контейнером и содержит значение 10.

x = x++;

Это можно разбить на:

1) increment the value contained in x 
    now x contains 11

2) return the value that was contained in x before it was incremented
    that is 10

3) assign that value to x
    now, x contains 10

Теперь выведите значение, содержащееся в x

Console.WriteLine(x);

И, что неудивительно, он печатает 10.

Answer 8

По определению x ++ возвращает значение x и затем увеличивает x.

http://blogs.msdn.com/lucabol/archive/2004/08/31/223580.aspx

Answer 9

Я знаю, что есть много ответов, и один из них принят, но я все равно добавлю два цента для еще одной точки зрения.

Я знаю, что этот вопрос был на C #, но я предполагаю, что для чего-то вроде постфиксного оператора он не отличается от C:

int main(){
    int x = 0;
    while (x<1)
        x = x++;
}

Сборка (да, я редактировал ее, чтобы сделать ее более читабельной), сгенерированная компилятором, показывает

...
    mov    -8(rbp), 0       ; x = 0
L1:
    cmp    -8(rbp), 1       ; if x >= 1,
    jge    L2               ;     leave the loop
    mov    eax, -8(rbp)     ; t1 = x
    mov    ecx, eax         ; t2 = t1
    add    ecx, 1           ; t2 = t2 + 1
    mov    -8(rbp), ecx     ; x  = t2 (so x = x + 1 !)
    mov    -8(rbp), eax     ; x  = t1 (kidding, it's the original value again)
    jmp    L1
L2:
...

Эквивалентно, цикл выполняет что-то вроде:

t = x
x = x + 1
x = t

Примечание: включение любых оптимизаций дает некоторый результат сборки, подобный следующему:

...
L1:
    jmp    L1
...

он даже не запоминает значение, которое вы ему сказали, чтобы дать x!

Answer 10

Первое, что вы делаете, называется «постинкремент», что означает, что

    int x = 10;
    x++; //x still is 10
    Console.WriteLine(x); //x is now 11(post increment)

поэтому, когда вы присваиваете x = x ++; х все равно 10, что вы могли бы сделать, если вам нужно, чтобы х было 11 в этой строке, напишите ++ x (подумайте, что это называется pre increment, исправьте меня, если я ошибаюсь) ... альтернативно right x ++; и чем х = х ++;

вопрос, зависит ли это от строки или от оператора, означающего, что он будет увеличиваться после;