Что такое x после "x = x ++"?

Ответ 1

x увеличивается. Но вы присваиваете старое значение x обратно в себя.

x = x++;

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

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

Ответ 2

x = x++;

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

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

Ответ 3

Заявление:

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 полностью определен, и нет места для изменения, зависящего от платформы. Компиляторам разрешено только изменять порядок операций, если это не изменит результат выполнения кода с точки зрения текущего потока. В этом случае компилятору будет разрешено оптимизировать весь оператор, потому что можно доказать, что он не работает.}

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

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

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

Ответ 4

int x = 7;
x = x++;

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

Ответ 5

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

Ответ 6

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

Ответ 7

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

Оба присваивания увеличивают 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

Ответ 8

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

Ответ 9

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

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

Ответ 10

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

x++;

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

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

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

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

++x;

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

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

Ответ 11

Что происходит, когда 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

Ответ 12

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

Ответ 13

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

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

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

int x = 7;
x = x++; 

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

• x инициализируется значением 7 Оператор
• post increment сохраняет предыдущее значение x i.e. 7. Возвращает.
• Увеличивает x, , поэтому теперь x равно 8
• Возвращает предыдущее значение x i.e. 7 и присваивается обратно x, поэтому x снова становится 7

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

Ответ 14

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

зависит от компилятора!

Ответ 15

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

Рассмотрим я ++ и ++ i, поскольку функции говорят Fun1 и Fun2.

Если я = 7; Функция я ++ (Fun1) возвращает 7, ++ я function (Fun2) возвращает 8 (это все знают). Внутренне обе функции увеличивают я до 8, но они возвращают разные значения.

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

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

Ответ 16

x = x ++;

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

Если вы хотите, чтобы произошло обратное: i.e "Прирастить операнд, а затем использовать значение операнда", вы должны использовать оператор pre-increment, как показано ниже.

x = ++ x;

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