Чому це переходить у нескінченну петлю?

У мене є такий код:

public class Tests {
    public static void main(String[] args) throws Exception {
        int x = 0;
        while(x<3) {
            x = x++;
            System.out.println(x);
        }
    }
}

Ми знаємо , що він повинен бути прописаний тільки x++або x=x+1, але x = x++він повинен першим атрибутом xдо себе, а потім збільшити його. Чому це xпродовжується 0як значення?

--оновити

Ось байт-код:

public class Tests extends java.lang.Object{
public Tests();
  Code:
   0:   aload_0
   1:   invokespecial   #1; //Method java/lang/Object."<init>":()V
   4:   return

public static void main(java.lang.String[])   throws java.lang.Exception;
  Code:
   0:   iconst_0
   1:   istore_1
   2:   iload_1
   3:   iconst_3
   4:   if_icmpge   22
   7:   iload_1
   8:   iinc    1, 1
   11:  istore_1
   12:  getstatic   #2; //Field java/lang/System.out:Ljava/io/PrintStream;
   15:  iload_1
   16:  invokevirtual   #3; //Method java/io/PrintStream.println:(I)V
   19:  goto    2
   22:  return

}

Я прочитаю про інструкції, щоб спробувати зрозуміти ...

Примітка : Спочатку я розмістив код C # у цій відповіді для ілюстрації, оскільки C # дозволяє передавати intпараметри за посиланням на refключове слово. Я вирішив оновити його фактичним юридичним кодом Java, використовуючи перший MutableIntклас, який я знайшов у Google, щоб наблизитись до того, що refробить у C #. Я не можу реально сказати, чи допомагає це чи шкодить відповіді. Я скажу, що особисто я ще не зробив так багато розробок Java; тому, наскільки я знаю, може бути набагато більше ідіоматичних способів проілюструвати цю точку.

Можливо, якщо ми випишемо метод зробити еквівалент того, що x++він робить, це зробить це зрозумілішим.

public MutableInt postIncrement(MutableInt x) {
    int valueBeforeIncrement = x.intValue();
    x.add(1);
    return new MutableInt(valueBeforeIncrement);
}

Правильно? Збільшити передане значення і повернути початкове значення: ось визначення оператора післярозвитку.

Тепер давайте подивимося, як ця поведінка відтворюється у вашому прикладі коду:

MutableInt x = new MutableInt();
x = postIncrement(x);

postIncrement(x)робить що? Зростання x, так. А потім повертає те, що x було до приросту . Потім це повертається значення присвоюється x.

Тож порядок призначень присвоєно x0, то 1, то 0.

Це може бути зрозуміліше, якщо ми перепишемо вище:

MutableInt x = new MutableInt();    // x is 0.
MutableInt temp = postIncrement(x); // Now x is 1, and temp is 0.
x = temp;                           // Now x is 0 again.

Ваша фіксація на тому, що замінюючи xліву частину вищезазначеного завдання на y", ви бачите, що спочатку він збільшується x, а пізніше приписує це y", вражає мене як заплутана. Це не xпризначено y; це значення, раніше присвоєнеx . Дійсно, введення ін'єкцій yне відрізняється від описаного вище сценарію; ми просто отримали:

MutableInt x = new MutableInt();    // x is 0.
MutableInt y = new MutableInt();    // y is 0.
MutableInt temp = postIncrement(x); // Now x is 1, and temp is 0.
y = temp;                           // y is still 0.

Тож зрозуміло: x = x++фактично не змінюється значення x. Завжди це призводить до того, що x має значення x ₀ , потім x ₀ + 1, а потім x ₀ знову.

Оновлення : Між іншим, щоб у вас не виникло сумнівів, що xколи-небудь присвоюється 1 "між" операцією збільшення та призначенням у наведеному вище прикладі, я зібрав швидку демонстрацію, щоб проілюструвати, що це проміжне значення дійсно "існує", хоча воно буде ніколи не бути "поміченим" на виконуваній нитці.

Демо-виклики x = x++;в циклі, тоді як окремий потік постійно друкує значення xконсолі.

public class Main {
    public static volatile int x = 0;

    public static void main(String[] args) {
        LoopingThread t = new LoopingThread();
        System.out.println("Starting background thread...");
        t.start();

        while (true) {
            x = x++;
        }
    }
}

class LoopingThread extends Thread {
    public @Override void run() {
        while (true) {
            System.out.println(Main.x);
        }
    }
}

Нижче наведено уривок виходу вищезгаданої програми. Помітьте нерегулярне виникнення як 1, так і 0.

Початкова нитка фону ...
0
0
1
1
0
0
0
0
0
0
0
0
0
0
1
0
1

x = x++ працює наступним чином:

• Спочатку він оцінює експресію x++. Оцінка цього виразу виробляє значення виразу (яке є значенням xдо збільшення) та збільшення кроків x.
• Пізніше він присвоює значення виразу x, замінюючи збільшене значення.

Отже, послідовність подій виглядає наступним чином (це фактичний декомпільований байт-код, як створено javap -cмоїми коментарями):

   8: iload_1 // Запам’ятайте поточне значення x у стеці
   9: iinc 1, 1 // Increment x (не змінює стек)
   12: istore_1 // Записати перезаписане значення з стека в x

Для порівняння x = ++x:

   8: iinc 1, 1 // Приріст x
   11: iload_1 // Натисніть значення x на стек
   12: istore_1 // Поп-значення зі стека до x

Це відбувається тому, що значення xзовсім не збільшується.

x = x++;

еквівалентно

int temp = x;
x++;
x = temp;

Пояснення:

Давайте розглянемо байт-код для цієї операції. Розглянемо зразок класу:

class test {
    public static void main(String[] args) {
        int i=0;
        i=i++;
    }
}

Тепер запустивши розбиральник класів на цьому, ми отримаємо:

$ javap -c test
Compiled from "test.java"
class test extends java.lang.Object{
test();
  Code:
   0:    aload_0
   1:    invokespecial    #1; //Method java/lang/Object."<init>":()V
   4:    return

public static void main(java.lang.String[]);
  Code:
   0:    iconst_0
   1:    istore_1
   2:    iload_1
   3:    iinc    1, 1
   6:    istore_1
   7:    return
}

Тепер Java VM заснований на стеці, що означає, що для кожної операції дані будуть висунуті на стек, а зі стека дані вискакують для виконання операції. Існує також інша структура даних, як правило, масив для зберігання локальних змінних. Локальні змінні задаються ідентифікаторами, які є лише індексами масиву.

Давайте подивимося на мнемоніки в main()методі:

• iconst_0: Постійне значення 0 висувається на стек.
• istore_1: Верхній елемент стеку вискакується і зберігається в локальній змінній з індексом, 1
  який є x.
• iload_1: Значення в розташуванні 1, значення x якого є 0, висувається в стек.
• iinc 1, 1: Значення в місці пам'яті 1збільшується на 1. Так xтепер стає 1.
• istore_1: Значення у верхній частині стека зберігається у пам'яті 1. Тобто 0присвоюється x перезапису його збільшення.

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

1. Позначення префікса збільшуватиме змінну, перш ніж вираження буде оцінено.
2. Позначення Postfix збільшиться ПІСЛЯ оцінки вираження.

Однак " =" має нижчий пріоритет оператора, ніж " ++".

Тож x=x++;слід оцінити так

1. x підготовлено до завдання (оцінено)
2. x приріст
3. Попереднє значення, xпризначене для x.

Жодна з відповідей там, де досить помітно, так ось що:

Коли ви пишете int x = x++, ви не призначите xсебе за новим значенням, ви присвоюєте xсобі зворотне значення x++виразу. Що, як виявляється, є первісною цінністю x, про що натякав у відповіді Колін Кокрайн .

Для задоволення протестуйте наступний код:

public class Autoincrement {
        public static void main(String[] args) {
                int x = 0;
                System.out.println(x++);
                System.out.println(x);
        }
}

Результат буде

0
1

Повернене значення виразу - це початкове значення x, яке дорівнює нулю. Але згодом, читаючи значення x, ми отримуємо оновлене значення, тобто одне.

Це вже добре пояснили інші. Я просто включаю посилання на відповідні розділи специфікації Java.

x = x ++ - це вираз. Java дотримуватиметься порядку оцінки . Спочатку буде оцінено вираз x ++, який збільшить x і встановить значення результату до попереднього значення x . Тоді він призначить результат вираження змінній x. Зрештою, х повертається до попереднього значення.

Ця заява:

x = x++;

оцінює так:

1. Натисніть xна штабель;
2. Приріст x;
3. Поп xіз стека.

Отже значення не змінюється. Порівняйте це з:

x = ++x;

який оцінюється як:

1. Приріст x;
2. Натисніть xна штабель;
3. Поп xіз стека.

Що ви хочете, це:

while (x < 3) {
  x++;
  System.out.println(x);
}

Відповідь досить проста. Це пов'язано з порядком оцінки речей. x++повертає значення xпотім з кроком x.

Отже, значення виразу x++є 0. Отже, ви призначаєте x=0кожен раз у циклі. Безумовно, x++збільшує це значення, але це відбувається перед призначенням.

З http://download.oracle.com/javase/tutorial/java/nutsandbolts/op1.html

Оператори збільшення / зменшення можуть бути застосовані до (префікса) або після (постфіксу) операнду. Результат коду ++; і ++ результат; обидва в результаті закінчуватимуться збільшенням одиниці. Єдина відмінність полягає в тому, що версія префікса (++ результат) оцінюється до прирощеного значення, тоді як версія постфіксу (результат ++) оцінюється до вихідного значення . Якщо ви просто виконуєте простий приріст / декремент, не важливо, яку версію ви обрали. Але якщо ви використовуєте цей оператор в частині більшого виразу, той, який ви вибрали, може суттєво змінити.

Для ілюстрації спробуйте наступне:

    int x = 0;
    int y = 0;
    y = x++;
    System.out.println(x);
    System.out.println(y);

Який надрукує 1 та 0.

Ви ефективно отримуєте таку поведінку.

1. схопимо значення x (яке дорівнює 0) як "результат" правої сторони
2. приріст значення x (тому x зараз дорівнює 1)
3. призначте результат правого боку (який було збережено як 0) до x (x зараз 0)

Ідея полягає в тому, що оператор після збільшення (x ++) збільшує цю змінну, про яку йде мова, ПІСЛЯ повертає її значення для використання в рівнянні, в якому він використовується.

Редагувати: Додавання трохи через коментар. Розглянемо це наступним чином.

x = 1;        // x == 1
x = x++ * 5;
              // First, the right hand side of the equation is evaluated.
  ==>  x = 1 * 5;    
              // x == 2 at this point, as it "gave" the equation its value of 1
              // and then gets incremented by 1 to 2.
  ==>  x = 5;
              // And then that RightHandSide value is assigned to 
              // the LeftHandSide variable, leaving x with the value of 5.

Вам не потрібен машинний код, щоб зрозуміти, що відбувається.

Відповідно до визначень:

1. Оператор присвоєння оцінює вираз правого боку та зберігає його у тимчасовій змінній.

   1.1. Поточне значення х копіюється в цю тимчасову змінну

   1.2. x збільшується зараз.

2. Потім тимчасова змінна копіюється в ліву частину виразу, що є випадково х! Тож тому старе значення х знову копіюється в себе.

Це досить просто.

Це тому, що він ніколи не збільшується в цьому випадку. x++спочатку використовуватиме його значення перед збільшенням, як у цьому випадку, воно буде таким:

x = 0;

Але якщо ви ++x;це зробите, це збільшиться.

Значення залишається рівним 0, оскільки значення x++дорівнює 0. У цьому випадку не має значення x, збільшується чи ні, значення x=0виконується. Це замінить тимчасове збільшення значення x(яке було 1 за "дуже короткий час").

Це працює так, як ви очікуєте від іншого. Це різниця між префіксом та постфіксом.

int x = 0; 
while (x < 3)    x = (++x);

Подумайте про x ++ як виклик функції, який "повертає" те, що було X до приросту (саме тому його називають пост-збільшенням).

Отже, порядок операцій:
1: кешувати значення x перед збільшенням
2: приріст x
3: повернути кешоване значення (x до його збільшення)
4: значення повернення призначається x

Коли значення ++ знаходиться на rhs, результат повертається перед збільшенням числа. Перейдіть на ++ x, і це було б добре. Java оптимізувала б це для виконання однієї операції (призначення x до x), а не збільшення.

Наскільки я можу бачити, помилка виникає внаслідок присвоєння, що перекриває збільшене значення, зі значенням до збільшення, тобто воно скасовує приріст.

Зокрема, вираз "x ++" має значення "x" перед збільшенням на відміну від "++ x", яке має значення "x" після збільшення.

Якщо ви зацікавлені в дослідженні байт-коду, ми розглянемо три питання, про які йдеться:

 7:   iload_1
 8:   iinc    1, 1
11:  istore_1

7: iload_1 # Поставить значення 2-ї локальної змінної на стек
8: iinc 1,1 # збільшить 2-ю локальну змінну на 1, зауважте, що вона залишає стек недоторканим!
9: istore_1 # Виведе верхню частину стека і збереже значення цього елемента у 2-й локальній змінній
(Ви можете прочитати ефекти кожної інструкції JVM тут )

Ось чому наведений вище код буде циклічно нескінченним, тоді як версія з ++ x не буде. Байт-код для ++ x повинен виглядати зовсім інакше, наскільки я пам'ятаю з компілятора 1.3 Java, про який писав трохи більше року тому, байт-код повинен мати щось подібне:

iinc 1,1
iload_1
istore_1

Тому просто поміняючи два перші рядки, змінює семантику таким чином, що значення, залишене у верхній частині стека, після збільшення (тобто «значення» виразу) є значенням після збільшення.

    x++
=: (x = x + 1) - 1

Тому:

   x = x++;
=> x = ((x = x + 1) - 1)
=> x = ((x + 1) - 1)
=> x = x; // Doesn't modify x!

Тоді як

   ++x
=: x = x + 1

Тому:

   x = ++x;
=> x = (x = x + 1)
=> x = x + 1; // Increments x

Звичайно, кінцевий результат такий самий, як просто x++;або ++x;на лінії сам по собі.

 x = x++; (increment is overriden by = )

через вищевикладене твердження x ніколи не досягає 3;

Цікаво, чи є в специфікації Java щось, що точно визначає поведінку цього. (Очевидним наслідком цього твердження є те, що я лінивий перевіряти.)

Зверніть увагу на байт-код Тома, ключові рядки - 7, 8 та 11. Рядок 7 завантажує x у стек обчислень. З кроком 8 рядка x. Рядок 11 зберігає значення з стека назад до x. У звичайних випадках, коли ви не присвоюєте собі значення назад, я не думаю, що це було б причиною, чому ви не змогли б завантажувати, зберігати, а потім збільшувати. Ви отримали такий же результат.

Припустимо, у вас був більш нормальний випадок, коли ви написали щось на кшталт: z = (x ++) + (y ++);

Чи було це сказано (псевдокод, щоб пропустити технічні характеристики)

load x
increment x
add y
increment y
store x+y to z

або

load x
add y
store x+y to z
increment x
increment y

має бути неактуальним. Будь-яка реалізація повинна бути дійсною, я думаю.

Я б був надзвичайно обережним щодо написання коду, який залежить від такої поведінки. Мені це здається дуже залежним від реалізації, між "тріщинами в техніці". Єдиний раз, коли це зміниться, якщо ви зробили щось божевільне, як, наприклад, приклад тут, або якщо у вас були два потоки, і ви залежали від порядку оцінки в виразі.

Я думаю, тому що у Java ++ вищий пріоритет, ніж = (призначення) ... Це? Подивіться на http://www.cs.uwf.edu/~eelsheik/cop2253/resources/op_precedence.html ...

Точно так само, якщо ви пишете x = x + 1 ... + має вищий пріоритет, ніж = (призначення)

x++Вираз має значення x. ++Частина впливає на вартість після оцінки , а НЕ після заяви . тому x = x++ефективно перекладається на

int y = x; // evaluation
x = x + 1; // increment part
x = y; // assignment

Перед збільшенням значення на одиницю значення присвоюється змінній.

Це відбувається тому, що він збільшується. Це означає, що змінна збільшується після оцінки виразу.

int x = 9;
int y = x++;

x зараз 10, але y дорівнює 9, значення x до його збільшення.

Детальніше дивіться у розділі Визначення посту збільшення .

Перевірте наведений нижче код,

    int x=0;
    int temp=x++;
    System.out.println("temp = "+temp);
    x = temp;
    System.out.println("x = "+x);

вихід буде,

temp = 0
x = 0

post incrementозначає приріст значення і повернення значення перед приростом . Ось чому значення tempє 0. То що робити, якщо temp = iце і є в циклі (крім першого рядка коду). так само, як у питанні !!!!

Оператор приросту застосовується до тієї ж змінної, яку ви призначаєте. Ось просить клопоту. Я впевнений, що ви можете бачити значення вашої змінної x під час роботи цієї програми .... це повинно дати зрозуміти, чому цикл ніколи не закінчується.