Что происходит (за шторами), когда это выполняется?
int x = 7;
x = x++;
То есть, когда переменная post увеличивается и присваивается себе в одном выражении? Я скомпилировал и выполнил это. x по-прежнему равен 7 даже после всего утверждения. В моей книге говорится, что x увеличивается.
x увеличивается. Но вы присваиваете старое значение x обратно в себя.
x = x++;
x++ увеличивает x и возвращает старое значение. 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 increment/decment - это значение операнда до того, как произойдет приращение/декремент. (В случае формы префикса значение - это значение операнда после операции,)
RHS выражения присваивания полностью оценивается (включая любые приращения, декременты и/или другие побочные эффекты) до того, как значение присваивается LHS.
Обратите внимание, что в отличие от C и С++ порядок оценки выражения в Java полностью определен, и нет места для изменения, зависящего от платформы. Компиляторам разрешено только изменять порядок операций, если это не изменит результат выполнения кода с точки зрения текущего потока. В этом случае компилятору будет разрешено оптимизировать весь оператор, потому что можно доказать, что он не работает.
Если это еще не очевидно:
Будем надеяться, что кодовые шашки, такие как FindBugs и PMD, будут считать этот код подозрительным.
int x = 7;
x = x++;
Он имеет поведение undefined в C и для Java см. этот ответ. Это зависит от того, что происходит.
Конструкция типа 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++;". Было бы 8, если бы вы сделали "x = ++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, поэтому x по-прежнему равно 7. ++ x будет равным 8, когда x называется
Когда вы повторно назначаете значение для x, оно все равно 7. Попробуйте x = ++x, и вы получите 8 else do
x++; // don't re-assign, just increment
System.out.println(x); // prints 8
потому что x ++ увеличивает значение AFTER, назначая его переменной. так и во время выполнения этой строки:
x++;
varialbe x по-прежнему будет иметь исходное значение (7), но с использованием x снова в другой строке, например
System.out.println(x + "");
предоставит вам 8.
если вы хотите использовать увеличенное значение x в операторе присваивания, используйте
++x;
Это увеличит x на 1, затем назначит это значение переменной x.
[Изменить] вместо x = x ++ это просто x ++; первый присваивает исходное значение x самому себе, поэтому он фактически ничего не делает на этой строке.
Что происходит, когда int x = 7; x = x++;?
ans → x++ означает первое значение использования x для выражения, а затем увеличивает его на 1.
Это то, что происходит в вашем случае. Значение x на RHS копируется в переменную x на LHS, а затем значение x увеличивается на 1.
Аналогично ++x означает -> увеличивать значение x сначала на единицу, а затем использовать в выражении.
Так что в вашем случае, если вы делаете x = ++x ; // where x = 7
вы получите значение 8.
Для большей ясности попробуйте выяснить, сколько команд printf выполнит следующий код
while(i++ <5)
printf("%d" , ++i); // This might clear your concept upto great extend
++x - pre-increment -> x увеличивается до, используемого x++ - это приращение -> x увеличивается после, используемого
int x = 7; -> x get 7 value <br>
x = x++; -> x get x value AND only then x is incremented
Оператор Post Increment работает следующим образом:
Итак, утверждение
int x = 7;
x = x++;
будет оцениваться следующим образом:
Итак, 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
зависит от компилятора!
Я думаю, что это противоречие можно решить, не вдаваясь в код и просто думать.
Рассмотрим я ++ и ++ i, поскольку функции говорят Fun1 и Fun2.
Если я = 7; Функция я ++ (Fun1) возвращает 7, ++ я function (Fun2) возвращает 8 (это все знают). Внутренне обе функции увеличивают я до 8, но они возвращают разные значения.
Итак, я = я ++ вызывает функцию Fun1. Внутри функции я увеличивается до 8, но по завершении функция возвращает 7.
Таким образом, в конечном итоге 7 получает i. (Итак, в конце я = 7; выполняется)
x = x ++;
Это оператор post-increment. Его следует понимать как "Использовать значение операнда, а затем увеличивать операнд".
Если вы хотите, чтобы произошло обратное: i.e "Прирастить операнд, а затем использовать значение операнда", вы должны использовать оператор pre-increment, как показано ниже.
x = ++ x;
Этот оператор сначала увеличивает значение x на 1, а затем присваивает значение обратно x.