Отсутствие инструкции update в выражении if делает бесконечный цикл [duplicate]

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

x = x++;

Случается, что вы присваиваете значение x x. x ++ увеличивает x после того, как значение x присваивается x. Так работают операторы post-increment. Они работают после выполнения заявления. Таким образом, в вашем коде x возвращается сначала после этого, после чего он увеличивается.

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

x = ++x;

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

x = x++;

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

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

int x = 7;
x = x++;

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

x = x ++;

Это оператор post-increment. Его следует понимать как «Использовать значение операнда, а затем увеличивать операнд».

Если вы хотите, чтобы произошло обратное, т.е. «Increment the operand, а затем используйте значение операнда», вы должны использовать оператор pre-increment, как показано ниже.

x = ++ x;

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

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

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

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

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

Случай 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 index: 1 type: int

Конструкция, подобная 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++, соответственно), очень легко ввести тонкие ошибки, которые трудно отследить вниз.

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

, поскольку x ++ увеличивает значение AFTER, назначая его переменной. так и во время выполнения этой строки:

x++;

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

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

предоставит вам 8.

, если вы хотите использовать добавочное значение x в инструкции присваивания, используйте

++x;

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

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

Итак, это означает: 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

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

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

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

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

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

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

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

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

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 increment / decment является значением операнда до , когда происходит приращение / декремент. (В случае формы префикса значение - это значение операнда после операции;)
• RHS выражения присваивания полностью оценивается (включая любые приращения, декременты и / или другие побочные эффекты) до значение присваивается LHS.

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

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

• "x = x ++;" почти наверняка является ошибкой в ​​любой программе.
• OP (для исходного вопроса!), вероятно, означал «x ++»; [x9]
• Заявления, которые объединяют auto inc / декремент и присваивание на одной и той же переменной, трудно понять, и , поэтому следует избегать независимо от того, их правильности . Просто не нужно писать такой код.

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

Оператор Post Increment работает следующим образом:

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

Таким образом, выражение

int x = 7;
x = x++; 

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

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

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