Dlaczego przechodzi to w nieskończoną pętlę?

Mam następujący kod:

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

Wiemy, że powinien był napisać sprawiedliwie x++lub x=x+1, ale na x = x++nim powinien najpierw przypisać xsobie, a później zwiększyć. Dlaczego xkontynuuje się 0jako wartość?

--aktualizacja

Oto kod bajtowy:

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

}

Przeczytam o instrukcjach, aby spróbować zrozumieć ...

Uwaga : pierwotnie opublikowałem kod C # w tej odpowiedzi w celach ilustracyjnych, ponieważ C # umożliwia przekazywanie intparametrów przez odniesienie do refsłowa kluczowego. Postanowiłem zaktualizować go o rzeczywisty legalny kod Java, używając pierwszej MutableIntklasy, którą znalazłem w Google, aby w przybliżeniu to, co refrobi w C #. Naprawdę nie wiem, czy to pomaga, czy boli odpowiedź. Powiem, że osobiście nie zrobiłem tyle rozwoju Java; więc o ile wiem, można zilustrować ten idiomatyczny sposób.

Być może, jeśli napiszemy metodę równoważną temu, co x++to uczyni, będzie to jaśniejsze.

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

Dobrze? Zwiększ przekazaną wartość i zwróć pierwotną wartość: taka jest definicja operatora poinkrementacji.

Zobaczmy teraz, jak wygląda to zachowanie w przykładowym kodzie:

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

postIncrement(x)robi co? Przyrosty x, tak. A potem zwraca to, co x było przed przyrostem . Ta zwracana wartość jest następnie przypisywana do x.

Tak więc kolejność przypisanych wartości xto 0, następnie 1, a następnie 0.

To może być jeszcze jaśniejsze, jeśli przepiszemy powyższe:

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.

Twoje przypuszczenie, że po zastąpieniu xpo lewej stronie powyższego zadania słowem y„widać, że najpierw zwiększa x, a później przypisuje je y”, wydaje mi się mylące. Nie xprzypisuje się tego y; jest to wartość poprzednio przypisanax . Naprawdę, wstrzykiwanie ynie różni się niczym od powyższego scenariusza; po prostu mamy:

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.

Jest więc jasne: x = x++skutecznie nie zmienia wartości x. Zawsze powoduje, że x ma wartości x ₀ , następnie x ₀ + 1, a następnie x ₀ ponownie.

Aktualizacja : Nawiasem mówiąc, aby nie wątpić, że xkiedykolwiek zostanie przypisane do 1 „pomiędzy” operacją przyrostową a przypisaniem w powyższym przykładzie, zrzuciłem szybkie demo, aby zilustrować, że ta wartość pośrednia rzeczywiście „istnieje”, chociaż będzie nigdy nie będzie „widoczny” w wątku wykonującym.

Demo wywołuje x = x++;pętlę, podczas gdy oddzielny wątek ciągle drukuje wartość xna konsoli.

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);
        }
    }
}

Poniżej znajduje się fragment wyników powyższego programu. Zwróć uwagę na nieregularne występowanie zarówno 1, jak i 0.

Rozpoczynam wątek w tle ...
0
0
1
1
0
0
0
0
0
0
0
0
0
0
1
0
1

x = x++ działa w następujący sposób:

• Najpierw ocenia wyrażenie x++. Ocena tego wyrażenia tworzy wartość wyrażenia (która jest wartością xprzed przyrostem) i przyrosty x.
• Później przypisuje wartość wyrażenia x, zastępując wartość przyrostową.

Tak więc sekwencja zdarzeń wygląda następująco (jest to faktycznie zdekompilowany kod bajtowy wytworzony przez javap -cmoje komentarze):

   8: iload_1 // Zapamiętaj bieżącą wartość x na stosie
   9: iinc 1, 1 // Przyrost x (nie zmienia stosu)
   12: istore_1 // Zapisz zapamiętaną wartość ze stosu do x

Dla porównania x = ++x:

   8: iinc 1, 1 // Przyrost x
   11: iload_1 // Wciśnij wartość x na stos
   12: istore_1 // Pop wartość ze stosu do x

Dzieje się tak, ponieważ wartość parametru xwcale się nie zwiększa.

x = x++;

jest równa

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

Wyjaśnienie:

Spójrzmy na kod bajtu dla tej operacji. Rozważ przykładową klasę:

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

Teraz uruchamiając dezasembler klas otrzymujemy:

$ 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
}

Teraz Java VM jest oparta na stosie, co oznacza, że ​​dla każdej operacji dane zostaną wypchnięte na stos, a ze stosu dane wyskoczą, aby wykonać operację. Istnieje również inna struktura danych, zazwyczaj tablica do przechowywania zmiennych lokalnych. Zmienne lokalne otrzymują identyfikatory, które są tylko indeksami tablicy.

Spójrzmy na mnemoniki w main()metodzie:

• iconst_0: Stała wartość 0 jest przekazywana na stos.
• istore_1: Górny element stosu jest wyskakujący i zapisywany w zmiennej lokalnej o indeksie, 1
  który jest x.
• iload_1: Wartość w lokalizacji 1, której wartość x jest 0, jest wypychana do stosu.
• iinc 1, 1: Wartość w miejscu pamięci 1jest zwiększana o 1. Tak się xteraz staje 1.
• istore_1: Wartość na górze stosu jest zapisywana w lokalizacji pamięci 1. Jest to 0przypisane do x zastąpienia jego przyrostowej wartości.

Dlatego wartość xnie zmienia się, co powoduje powstanie nieskończonej pętli.

1. Notacja prefiksu zwiększy zmienną PRZED obliczeniem wyrażenia.
2. Notacja Postfiksa zwiększy się PO ocenie wyrażenia.

Jednak „ =” ma niższy priorytet operatora niż „ ++”.

Więc x=x++;powinien oceniać w następujący sposób

1. x przygotowane do zadania (ocenione)
2. x zwiększony
3. Poprzednia wartość xprzypisana do x.

Żadna z odpowiedzi nie była na miejscu, więc oto:

Kiedy piszesz int x = x++, nie przypisujesz xsiebie do nowej wartości, przypisujesz, xże jest to wartość zwracana x++wyrażenia. Która okazuje się być oryginalną wartością x, jak wskazano w odpowiedzi Colina Cochrane'a .

Dla zabawy przetestuj następujący kod:

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

Wynik będzie

0
1

Zwracana wartość wyrażenia jest wartością początkową x, która wynosi zero. Ale później, czytając wartość x, otrzymujemy zaktualizowaną wartość, to jest jedną.

Zostało to już dobrze wyjaśnione przez innych. Podaję tylko linki do odpowiednich sekcji specyfikacji Java.

x = x ++ jest wyrażeniem. Java zastosuje się do kolejności oceny . Najpierw oceni wyrażenie x ++, które zwiększy x i ustawi wartość wynikową na poprzednią wartość x . Następnie przypisze wynik wyrażenia do zmiennej x. Na koniec x powraca do poprzedniej wartości.

To oświadczenie:

x = x++;

ocenia tak:

1. Pchać x na stos;
2. Przyrost x;
3. Wyskakuj xze stosu.

Zatem wartość pozostaje niezmieniona. Porównaj to z:

x = ++x;

który ocenia jako:

1. Przyrost x;
2. Wciśnijx na stos;
3. Wyskakuj xze stosu.

Co chcesz to:

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

Odpowiedź jest dość prosta. Ma to związek z kolejnością oceniania rzeczy. x++zwraca wartość, xa następnie zwiększa x.

W związku z tym wartość wyrażenia x++wynosi 0. Więc przypisujesz za x=0każdym razem w pętli. Na pewnox++ zwiększa tę wartość, ale dzieje się to przed przypisaniem.

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

Operatory inkrementacji / dekrementacji można zastosować przed (prefiksem) lub po (postfiksie) operandu. Wynik kodu ++; i wynik ++; oba zakończą się zwiększeniem o jeden. Jedyną różnicą jest to, że wersja przedrostka (wynik ++) ocenia na wartość przyrostową, podczas gdy wersja po przedrostku (wynik ++) ocenia na wartość pierwotną . Jeśli wykonujesz prosty przyrost / spadek, tak naprawdę nie ma znaczenia, którą wersję wybierzesz. Ale jeśli użyjesz tego operatora jako części większego wyrażenia, ten, który wybierzesz, może mieć znaczącą różnicę.

Aby to zilustrować, spróbuj wykonać następujące czynności:

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

Które wypisze 1 i 0.

Skutecznie uzyskujesz następujące zachowanie.

1. pobierz wartość x (która wynosi 0) jako „wynik” prawej strony
2. zwiększ wartość x (więc x wynosi teraz 1)
3. przypisz wynik prawej strony (który został zapisany jako 0) do x (x jest teraz 0)

Chodzi o to, że operator post-inkrementacji (x ++) zwiększa tę zmienną PO zwróceniu jej wartości do wykorzystania w równaniu, w którym jest używana.

Edycja: Trochę dodaje z powodu komentarza. Rozważ to w następujący sposób.

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.

Tak naprawdę nie potrzebujesz kodu maszynowego, aby zrozumieć, co się dzieje.

Zgodnie z definicjami:

1. Operator przypisania ocenia wyrażenie po prawej stronie i przechowuje je w zmiennej tymczasowej.

   1.1 Bieżąca wartość x jest kopiowana do tej zmiennej tymczasowej

   1.2 x jest teraz zwiększane.

2. Zmienna tymczasowa jest następnie kopiowana do lewej strony wyrażenia, czyli przypadkowo x! Dlatego właśnie stara wartość x jest ponownie kopiowana do siebie.

To jest dość proste.

Jest tak, ponieważ w tym przypadku nigdy się nie zwiększa. x++użyje jego wartości najpierw przed inkrementacją, jak w tym przypadku będzie to wyglądało tak:

x = 0;

Ale jeśli to zrobisz ++x;, wzrośnie.

Wartość pozostaje na 0, ponieważ wartość x++wynosi 0. W tym przypadku nie ma znaczenia, czy wartość parametru xjest zwiększona, czy nie, przypisanie x=0jest wykonywane. Spowoduje to zastąpienie tymczasowej wartości przyrostowej x(która wynosiła 1 przez „bardzo krótki czas”).

Działa to tak, jak oczekujesz tego drugiego. Jest to różnica między przedrostkiem i postfiksem.

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

Pomyśl o x ++ jako wywołaniu funkcji, która „zwraca” to, co X był wcześniej inkrementem (dlatego nazywa się to inkrementacją post-inkrement).

Zatem kolejność operacji jest następująca:
1: buforuj wartość x przed inkrementacją
2: inkrement x
3: zwróć buforowaną wartość (x przed jej inkrementacją)
4: zwracana wartość jest przypisywana do x

Gdy ++ jest na rhs, wynik jest zwracany przed zwiększeniem liczby. Zmień na ++ x i byłoby dobrze. Java zoptymalizowałoby to, aby wykonać pojedynczą operację (przypisanie x do x) zamiast przyrostu.

O ile widzę, błąd występuje z powodu przypisania zastępującego wartość przyrostową wartością przed przyrostem, tzn. Cofa przyrost.

W szczególności wyrażenie „x ++” ma wartość „x” przed inkrementem, w przeciwieństwie do „++ x”, który ma wartość „x” po inkrementacji.

Jeśli jesteś zainteresowany badaniem kodu bajtowego, przyjrzymy się trzem pytaniom:

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

7:
iload_1 # Umieści wartość 2. zmiennej lokalnej na stosie 8: iinc 1,1 # zwiększy 2. zmienną lokalną o 1, zauważ, że pozostawia stos nietknięty!
9: istore_1 # Wyskoczy na górze stosu i zapisze wartość tego elementu w drugiej zmiennej lokalnej
(Możesz przeczytać efekty każdej instrukcji JVM tutaj )

Dlatego powyższy kod będzie się zapętlał w nieskończoność, podczas gdy wersja z ++ x nie. Kod bajtowy dla ++ x powinien wyglądać zupełnie inaczej, o ile pamiętam z kompilatora Java 1.3 napisanego nieco ponad rok temu, kod bajtowy powinien wyglądać mniej więcej tak:

iinc 1,1
iload_1
istore_1

Zatem zamiana dwóch pierwszych wierszy zmienia semantykę, tak że wartość pozostawiona na górze stosu po inkrementie (tj. „Wartość” wyrażenia) jest wartością po inkrementie.

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

Więc:

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

Natomiast

   ++x
=: x = x + 1

Więc:

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

Oczywiście wynik końcowy jest taki sam jak sam x++;lub ++x;na linii.

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

z powodu powyższego wyrażenia x nigdy nie osiąga 3;

Zastanawiam się, czy jest coś w specyfikacji Java, która precyzyjnie określa zachowanie tego. (Oczywiście implikacją tego stwierdzenia jest to, że jestem zbyt leniwy, by to sprawdzić).

Uwaga z kodu bajtowego Toma kluczowe linie to 7, 8 i 11. Linia 7 ładuje x do stosu obliczeniowego. Przyrosty linii 8 x. Wiersz 11 przechowuje wartość ze stosu z powrotem do x. W normalnych przypadkach, gdy nie przypisujesz sobie wartości z powrotem, nie sądzę, aby istniał jakiś powód, dla którego nie można załadować, zapisać, a następnie zwiększyć. Otrzymasz ten sam wynik.

Załóżmy, że miałeś bardziej normalny przypadek, w którym napisałeś coś takiego: z = (x ++) + (y ++);

Czy to powiedział (pseudokod, aby pominąć dane techniczne)

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

lub

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

powinno być nieistotne. Wydaje mi się, że każde wdrożenie powinno być ważne.

Byłbym bardzo ostrożny przy pisaniu kodu, który zależy od tego zachowania. Wygląda mi na bardzo zależne od implementacji, między pęknięciami w specyfikacjach. Jedyne, co zrobiłoby różnicę to to, że zrobiłeś coś szalonego, na przykład tutaj, lub jeśli działały dwa wątki i były zależne od kolejności oceny w wyrażeniu.

Myślę, że ponieważ w Javie ++ ma wyższy priorytet niż = (przypisanie) ... Czy tak? Spójrz na http://www.cs.uwf.edu/~eelsheik/cop2253/resources/op_precedence.html ...

Ten sam sposób, jeśli piszesz x = x + 1 ... + ma wyższy priorytet niż = (przypisanie)

x++Wyrażenie to x. ++Część wpływu na wartość po ocenie , nie po oświadczeniu . więc x = x++jest skutecznie przetłumaczone na

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

Przed zwiększeniem wartości o jeden wartość jest przypisywana do zmiennej.

Dzieje się tak, ponieważ jest zwiększany. Oznacza to, że zmienna jest zwiększana po ocenie wyrażenia.

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

x wynosi teraz 10, ale y wynosi 9, wartość x przed zwiększeniem.

Zobacz więcej w Definicja przyrostu postu .

Sprawdź poniższy kod,

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

wyjście będzie,

temp = 0
x = 0

post incrementoznacza zwiększenie wartości i zwrócenie wartości przed przyrostem . Właśnie dlatego wartość tempjest 0. Co jeśli temp = ii to jest w pętli (z wyjątkiem pierwszego wiersza kodu). tak jak w pytaniu !!!!

Operator przyrostu jest stosowany do tej samej zmiennej, do której przypisujesz. To prosi o kłopoty. Jestem pewien, że możesz zobaczyć wartość swojej zmiennej x podczas uruchamiania tego programu ... to powinno wyjaśnić, dlaczego pętla nigdy się nie kończy.