Dlaczego i = i + daje mi 0?

Mam prosty program:

public class Mathz {
    static int i = 1;
    public static void main(String[] args) {    
        while (true){
            i = i + i;
            System.out.println(i);
        }
    }
}

Kiedy uruchomić ten program, wszystko co widzę to 0na imoim wyjściu. Spodziewałbym się, że za pierwszym razem będziemy mieć i = 1 + 1, a i = 2 + 2następnie i = 4 + 4itd.

Czy wynika to z faktu, że gdy tylko spróbujemy ponownie zadeklarować ipo lewej stronie, jej wartość zostanie zresetowana do 0?

Byłoby wspaniale, gdyby ktokolwiek mógł wskazać mi szczegóły tej sprawy.

Zmienić intsię longi wydaje się być drukowanie numerów zgodnie z oczekiwaniami. Jestem zaskoczony, jak szybko osiąga maksymalną wartość 32-bitową!

Problem wynika z przepełnienia liczb całkowitych.

W 32-bitowej arytmetyce z uzupełnieniem do dwóch:

ifaktycznie zaczyna się od wartości potęgi dwóch, ale potem zachowania związane z przepełnieniem zaczynają się, gdy osiągniesz 2 ³⁰ :

2 ³⁰ + 2 ³⁰ = -2 ³¹

-2 ³¹ + -2 ³¹ = 0

... w intarytmetyce, ponieważ jest to zasadniczo arytmetyczny mod 2 ^ 32.

Wprowadzenie

Problem polega na przepełnieniu liczb całkowitych. Jeśli się przepełni, wraca do wartości minimalnej i kontynuuje od tego momentu. Jeśli spada, wraca do wartości maksymalnej i kontynuuje od tego momentu. Poniższy obraz przedstawia licznik kilometrów. Używam tego, aby wyjaśnić przepełnienia. To mechaniczny przelew, ale wciąż dobry przykład.

W liczniku kilometrów, max digit = 9więc wykracza poza maksymalne średnie 9 + 1, które przenosi i daje 0; Jednak nie ma wyższej cyfry do zmiany na a 1, więc licznik resetuje się do zero. Masz pomysł - teraz przychodzą mi na myśl „przepełnienia całkowitoliczbowe”.

Największy dosłownym dziesiętny typu int to 2147483647 (2 ³¹ 1). Wszystkie literały dziesiętne od 0 do 2147483647 mogą pojawić się wszędzie tam, gdzie może pojawić się literał int, ale literał 2147483648 może pojawić się tylko jako operand jednoargumentowego operatora negacji -.

Jeśli dodawanie liczb całkowitych przepełnia, wynikiem są najmniejsze bity sumy matematycznej, reprezentowane w jakimś wystarczająco dużym formacie uzupełnienia do dwóch. Jeśli wystąpi przepełnienie, znak wyniku nie jest taki sam, jak znak sumy matematycznej dwóch wartości operandów.

W ten sposób 2147483647 + 1przepełnia się i zawija do -2147483648. Stąd int i=2147483647 + 1byłby przepełniony, co nie jest równe 2147483648. Mówisz też „zawsze wypisuje 0”. Nie, ponieważ http://ideone.com/WHrQIW . Poniżej te 8 liczb pokazuje punkt, w którym obraca się i przepełnia. Następnie zaczyna drukować zera. Nie zdziw się też, jak szybko to oblicza, dzisiejsze maszyny są szybkie.

268435456
536870912
1073741824
-2147483648
0
0
0
0

Dlaczego przepełnienie liczb całkowitych „zawija się”

^{Oryginalny plik PDF}

Nie, nie drukuje tylko zer.

Zmień to na to, a zobaczysz, co się stanie.

    int k = 50;
    while (true){
        i = i + i;
        System.out.println(i);
        k--;
        if (k<0) break;
    }

To, co się dzieje, nazywa się przepełnieniem.

static int i = 1;
    public static void main(String[] args) throws InterruptedException {
        while (true){
            i = i + i;
            System.out.println(i);
            Thread.sleep(100);
        }
    }

wynik:

2
4
8
16
32
64
...
1073741824
-2147483648
0
0

when sum > Integer.MAX_INT then assign i = 0;

Ponieważ nie mam wystarczającej reputacji, nie mogę opublikować zdjęcia wyjścia tego samego programu w C z kontrolowanym wyjściem, możesz spróbować sam i zobaczyć, że faktycznie drukuje 32 razy, a następnie jak wyjaśniono z powodu przepełnienia i = 1073741824 + 1073741824 zmienia się na -2147483648 i jeszcze jeden dodatek jest poza zakresem int i zmienia się w Zero.

#include<stdio.h>
#include<conio.h>

int main()
{
static int i = 1;

    while (true){
        i = i + i;
      printf("\n%d",i);
      _getch();
    }
      return 0;
}

Wartość ijest przechowywana w pamięci przy użyciu ustalonej liczby cyfr binarnych. Gdy numer wymaga więcej cyfr niż jest dostępnych, przechowywane są tylko najniższe cyfry (najwyższe cyfry zostaną utracone).

Dodawanie ido siebie jest tym samym, co mnożenie iprzez dwa. Podobnie jak pomnożenie liczby przez dziesięć w notacji dziesiętnej można wykonać przesuwając każdą cyfrę w lewo i wstawiając zero po prawej stronie, tak samo można wykonać pomnożenie liczby przez dwa w notacji binarnej. Spowoduje to dodanie jednej cyfry po prawej stronie, więc cyfra zostanie utracona po lewej stronie.

Tutaj wartością początkową jest 1, więc jeśli użyjemy 8 cyfr do przechowywania i(na przykład),

• po 0 iteracjach wartość wynosi 00000001
• po 1 iteracji wartość wynosi 00000010
• po 2 iteracjach wartość wynosi 00000100

i tak dalej, aż do ostatniego niezerowego kroku

• po 7 iteracjach wartość wynosi 10000000
• po 8 iteracjach wartość wynosi 00000000

Bez względu na to, ile cyfr binarnych jest przydzielonych do przechowywania numeru i bez względu na wartość początkową, ostatecznie wszystkie cyfry zostaną utracone, gdy zostaną przesunięte w lewo. Po tym czasie dalsze podwojenie liczby nie zmieni liczby - nadal będzie reprezentowana przez wszystkie zera.

To prawda, ale po 31 iteracjach 1073741824 + 1073741824 nie oblicza poprawnie i po tym drukuje tylko 0.

Możesz refaktoryzować, aby użyć BigInteger, aby Twoja nieskończona pętla działała poprawnie.

public class Mathz {
    static BigInteger i = new BigInteger("1");

    public static void main(String[] args) {    

        while (true){
            i = i.add(i);
            System.out.println(i);
        }
    }
}

Do debugowania takich przypadków dobrze jest zmniejszyć liczbę iteracji w pętli. Użyj tego zamiast swojego while(true):

for(int r = 0; r<100; r++)

Możesz wtedy zobaczyć, że zaczyna się od 2 i podwaja wartość, aż spowoduje przepełnienie.

Do ilustracji użyję 8-bitowej liczby, ponieważ można ją szczegółowo opisać w niewielkiej przestrzeni. Liczby szesnastkowe zaczynają się od 0x, a liczby binarne od 0b.

Maksymalna wartość 8-bitowej liczby całkowitej bez znaku to 255 (0xFF lub 0b11111111). Jeśli dodasz 1, zwykle oczekujesz: 256 (0x100 lub 0b100000000). Ale ponieważ jest to zbyt wiele bitów (9), to jest powyżej maksimum, więc pierwsza część zostaje po prostu odrzucona, pozostawiając efektywnie 0 (0x (1) 00 lub 0b (1) 00000000, ale z 1 odrzuconym).

Więc kiedy program działa, otrzymujesz:

1 = 0x01 = 0b1
2 = 0x02 = 0b10
4 = 0x04 = 0b100
8 = 0x08 = 0b1000
16 = 0x10 = 0b10000
32 = 0x20 = 0b100000
64 = 0x40 = 0b1000000
128 = 0x80 = 0b10000000
256 = 0x00 = 0b00000000 (wraps to 0)
0 + 0 = 0 = 0x00 = 0b00000000
0 + 0 = 0 = 0x00 = 0b00000000
0 + 0 = 0 = 0x00 = 0b00000000
...

Największy literał dziesiętny typu intto 2147483648 (= 2 ³¹ ). Wszystkie literały dziesiętne od 0 do 2147483647 mogą pojawić się wszędzie tam, gdzie może wystąpić literał int, ale literał 2147483648 może pojawić się tylko jako operand jednoargumentowego operatora negacji -.

Jeśli dodawanie liczb całkowitych przepełnia, wynikiem są najmniejsze bity sumy matematycznej, reprezentowane w jakimś wystarczająco dużym formacie uzupełnienia do dwóch. Jeśli wystąpi przepełnienie, znak wyniku nie jest taki sam, jak znak sumy matematycznej dwóch wartości operandów.