Что такое х после «х = х ++»?

Что происходит (за занавесом), когда это выполняется?

int x = 7;
x = x++;

То есть, когда переменная увеличивается на единицу и присваивается себе в одном выражении? Я скомпилировал и выполнил это. xеще 7 даже после всего заявления . В моей книге говорится, что xувеличивается!

xдействительно увеличивается. Но вы назначаете старую ценность xобратно в себя.

x = x++;

1. x++увеличивает xи возвращает его старое значение.
2. x = присваивает старое значение себе

Таким образом, в конце концов, xвозвращается обратно к своему начальному значению.

x = x++;

эквивалентно

int tmp = x;
x++;
x = tmp;

Заявление:

x = x++;

эквивалентно:

tmp = x;   // ... this is capturing the value of "x++"
x = x + 1; // ... this is the effect of the increment operation in "x++" which
           //     happens after the value is captured.
x = tmp;   // ... this is the effect of assignment operation which is
           //     (unfortunately) clobbering the incremented value.

Короче говоря, заявление не имеет никакого эффекта.

Ключевые моменты:

• Значение выражения увеличения / уменьшения Postfix - это значение операнда до того, как произойдет увеличение / уменьшение. (В случае формы префикса значением является значение операнда после операции)

• RHS выражения присваивания полностью оценивается (включая любые приращения, уменьшения и / или другие побочные эффекты) до того, как значение присваивается LHS.

_{Обратите внимание, что в отличие от C и C ++, порядок вычисления выражения в Java полностью указан, и нет места для изменения, зависящего от платформы. Компиляторам разрешено переупорядочивать операции только в том случае, если это не изменит результат выполнения кода с точки зрения текущего потока. В этом случае компилятору будет разрешено оптимизировать весь оператор, поскольку можно доказать, что он не используется.}

Если это еще не очевидно:

• "х = х ++;" почти наверняка ошибка в любой программе.
• ОП (для первоначального вопроса!), Вероятно, означало «x ++;» а не "x = x ++;".
• Утверждения, которые комбинируют автоматическое увеличение / уменьшение и присваивание для одной и той же переменной, трудно понять, и поэтому их следует избегать независимо от их правильности . Просто нет необходимости писать такой код.

Надеемся, что программы проверки кода, такие как FindBugs и PMD, будут отмечать код как подозрительный.

int x = 7;
x = x++;

Он имеет неопределенное поведение в C и для Java см. Этот ответ . Это зависит от компилятора, что произойдет.

Конструкция like x = x++;показывает, что вы, вероятно, неправильно понимаете, что ++делает оператор:

// original code
int x = 7;
x = x++;

Давайте перепишем это, чтобы сделать то же самое, основываясь на удалении ++оператора:

// behaves the same as the original code
int x = 7;
int tmp = x; // value of tmp here is 7
x = x + 1; // x temporarily equals 8 (this is the evaluation of ++)
x = tmp; // oops! we overwrote y with 7

Теперь давайте перепишем это, чтобы сделать (что я думаю), что вы хотели:

// original code
int x = 7;
x++;

Тонкость здесь заключается в том, что ++оператор изменяет переменнуюx , в отличие от такого выражения, как x + x, которое будет вычислять значение int, но сама переменная останется xнеизменной. Рассмотрим такую ​​конструкцию, как почтенный forцикл:

for(int i = 0; i < 10; i++)
{
    System.out.println(i);
}

Заметили i++там? Это тот же оператор. Мы можем переписать этот forцикл следующим образом, и он будет вести себя так же:

for(int i = 0; i < 10; i = i + 1)
{
    System.out.println(i);
}

Я также рекомендую не использовать ++оператор в больших выражениях в большинстве случаев. Из-за тонкости того, когда она изменяет исходную переменную до пост-приращения ( ++xи x++, соответственно), очень легко вводить тонкие ошибки, которые трудно отследить.

Согласно байт-коду полученному из файлов классов,

Оба назначения увеличивают х, но разница заключается во времени when the value is pushed onto the stack

В Case1 , Push происходит (а затем назначается позже) до приращения (по сути, это означает, что ваш прирост ничего не делает)

В Case2 , сначала происходит инкремент (делая его 8), а затем помещается в стек (а затем назначается х)

Случай 1:

int x=7;
x=x++;

Байт-код:

0  bipush 7     //Push 7 onto  stack
2  istore_1 [x] //Pop  7 and store in x
3  iload_1  [x] //Push 7 onto stack
4  iinc 1 1 [x] //Increment x by 1 (x=8)
7  istore_1 [x] //Pop 7 and store in x
8  return       //x now has 7

Случай 2:

int x=7; 
x=++x;

Байт код

0  bipush 7     //Push 7 onto stack
2  istore_1 [x] //Pop 7 and store in x
3  iinc 1 1 [x] //Increment x by 1 (x=8)
6  iload_1  [x] //Push x onto stack
7  istore_1 [x] //Pop 8 and store in x
8  return       //x now has 8

• Стек здесь относится к стеку операндов, локальный: x индекс: 1 тип: int

Увеличивается после " x = x++;". Было бы 8, если бы вы сделали " x = ++x;".

Постинкрементный оператор работает следующим образом:

1. Сохранить предыдущее значение операнда.
2. Увеличьте значение операнда.
3. Вернуть предыдущее значение операнда.

Итак, утверждение

int x = 7;
x = x++; 

будет оцениваться следующим образом:

1. х инициализируется значением 7
2. Оператор постинкрементного хранения сохраняет предыдущее значение x, т. е. 7 для возврата.
3. Увеличивает х, так что теперь х равен 8
4. Возвращает предыдущее значение x, то есть 7, и оно присваивается обратно x, поэтому x снова становится 7

Таким образом, x действительно увеличивается, но поскольку x ++ присваивает результат обратно x, значение x переопределяется на предыдущее значение.

Инкремент происходит после вызова x, поэтому x по-прежнему равен 7. ++ x будет равен 8 при вызове x

Когда вы переназначаете значение, xоно все еще равно 7. Попробуйте, x = ++xи вы получите 8, иначе сделайте

x++; // don't re-assign, just increment
System.out.println(x); // prints 8

потому что x ++ увеличивает значение ПОСЛЕ присвоения его переменной. так далее и во время выполнения этой строки:

x++;

переменная x будет по-прежнему иметь исходное значение (7), но снова использовать x в другой строке, например

System.out.println(x + "");

даст вам 8.

если вы хотите использовать увеличенное значение x в вашем операторе присваивания, используйте

++x;

Это увеличит x на 1, ТО затем присвоит это значение переменной x.

[Edit] вместо x = x ++, это просто x ++; первый присваивает исходное значение x самому себе, поэтому он фактически ничего не делает в этой строке.

Что происходит, когда int x = 7; x = x++; ?

ans -> x++означает сначала использовать значение x для выражения, а затем увеличить его на 1.
Это то, что происходит в вашем случае. Значение x в RHS копируется в переменную x в LHS, а затем значениеx увеличивается на 1.

Аналогично ++x означает ->увеличение значения х сначала на единицу, а затем использовать в выражении.
Так что в вашем случае, если вы это сделаете, x = ++x ; // where x = 7
вы получите значение 8.

Для большей ясности попытайтесь выяснить, сколько операторов printf выполнит следующий код

while(i++ <5)   
  printf("%d" , ++i);   // This might clear your concept upto  great extend

++xэто постинкремент ->x увеличивается перед использованием
x++это постинкремент ->x увеличивается после использования

int x = 7; -> x get 7 value <br>
x = x++; -> x get x value AND only then x is incremented

Так что это означает: x++не равноx = x+1

так как:

int x = 7; x = x++;
x is 7

int x = 7; x = x = x+1;
x is 8

и теперь это кажется немного странным:

int x = 7; x = x+=1;
x is 8

очень зависит от компилятора!

х = х ++;

Это оператор после увеличения. Это следует понимать как «Использовать значение операнда и затем увеличивать операнд».

Если вы хотите, чтобы произошло обратное, то есть «Увеличьте операнд, а затем используйте значение операнда», вы должны использовать оператор предварительного увеличения, как показано ниже.

х = ++ х;

Этот оператор сначала увеличивает значение x на 1, а затем присваивает значение обратно x.

Я думаю, что этот спор можно решить, не вдаваясь в код и просто подумав.

Рассмотрим i ++ & ++ i как функции, скажем Func1 & Func2.

Теперь я = 7;
Func1 (i ++) возвращает 7, Func2 (++ i) возвращает 8 (это знают все). Внутри обе функции увеличивают i до 8, но они возвращают разные значения.

Поэтому я = i ++ вызывает функцию Func1. Внутри функции i увеличивается до 8, но по завершении функция возвращает 7.

Таким образом, в конечном итоге 7 получает я. (Итак, в итоге я = 7)

Это потому, что вы использовали оператор постинкрементного. В этой следующей строке кода

x = x++;

Что происходит, вы присваиваете значение x для x. x ++ увеличивает x после того, как значение x присвоено x. Вот как работают операторы постинкрементной обработки. Они работают после того, как заявление было выполнено. Таким образом, в вашем коде x возвращается первым, а затем постепенно увеличивается.

Если вы сделали

x = ++x;

Ответ будет 8, потому что вы использовали оператор предварительного увеличения. Это увеличивает значение перед возвратом значения x.