Warum gibt i = i + i mir 0?

Ich habe ein einfaches Programm:

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

Als ich dieses Programm ausführen, alles , was ich sehe , ist 0für iin meiner Ausgabe. Ich hätte das erste Mal erwartete Runde haben wir würden i = 1 + 1, gefolgt von i = 2 + 2, gefolgt von i = 4 + 4usw.

Liegt das daran, dass ider Wert auf den Wert zurückgesetzt wird, sobald wir versuchen, ihn auf der linken Seite erneut zu deklarieren 0?

Wenn mich jemand auf die Einzelheiten hinweisen kann, wäre das großartig.

Ändern Sie das intin longund es scheint, als würden Zahlen wie erwartet gedruckt. Ich bin überrascht, wie schnell es den maximalen 32-Bit-Wert erreicht!

Das Problem ist auf einen Ganzzahlüberlauf zurückzuführen.

In 32-Bit-Zweierkomplement-Arithmetik:

iEs beginnt zwar mit Zweierpotenzwerten, aber dann beginnt das Überlaufverhalten, sobald Sie 2 ^{30 erreicht haben} :

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

-2 ³¹ + -2 ³¹ = 0

... in der intArithmetik, da es im Wesentlichen arithmetische Mod 2 ^ 32 ist.

Einführung

Das Problem ist ein ganzzahliger Überlauf. Wenn es überläuft, kehrt es zum Minimalwert zurück und fährt von dort fort. Wenn es unterläuft, kehrt es zum Maximalwert zurück und fährt von dort fort. Das Bild unten zeigt einen Kilometerzähler. Ich benutze dies, um Überläufe zu erklären. Es ist ein mechanischer Überlauf, aber immer noch ein gutes Beispiel.

In einem Kilometerzähler, der max digit = 9über das Maximum hinausgeht 9 + 1, überträgt und gibt ein 0; Es gibt jedoch keine höhere Ziffer, die in a geändert werden kann 1, sodass der Zähler auf zurückgesetzt wird zero. Sie haben die Idee - "Integer Overflows" kommen jetzt in den Sinn.

Das größte Dezimalliteral vom Typ int ist 2147483647 (2 ³¹ -1). Alle Dezimalliterale von 0 bis 2147483647 können überall dort erscheinen, wo ein int-Literal erscheinen kann, aber das Literal 2147483648 kann nur als Operand des unären Negationsoperators erscheinen -.

Wenn eine ganzzahlige Addition überläuft, sind das Ergebnis die niederwertigen Bits der mathematischen Summe, wie sie in einem ausreichend großen Zweierkomplementformat dargestellt werden. Wenn ein Überlauf auftritt, stimmt das Vorzeichen des Ergebnisses nicht mit dem Vorzeichen der mathematischen Summe der beiden Operandenwerte überein.

Somit 2147483647 + 1läuft über und wickelt sich um -2147483648. Daher int i=2147483647 + 1wäre übergelaufen, was nicht gleich ist 2147483648. Außerdem sagen Sie "es wird immer 0 gedruckt". Dies ist nicht der Fall, da http://ideone.com/WHrQIW . Unten zeigen diese 8 Zahlen den Punkt, an dem es schwenkt und überläuft. Es beginnt dann, Nullen zu drucken. Seien Sie auch nicht überrascht, wie schnell es berechnet, die Maschinen von heute sind schnell.

268435456
536870912
1073741824
-2147483648
0
0
0
0

Warum ein ganzzahliger Überlauf "umhüllt"

^{Original PDF}

Nein, es werden nicht nur Nullen gedruckt.

Wenn Sie dies ändern, werden Sie sehen, was passiert.

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

Was passiert, nennt man Überlauf.

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

Ausgabe:

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

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

Da ich nicht genug Ruf habe, kann ich das Bild der Ausgabe für dasselbe Programm nicht in C mit kontrollierter Ausgabe veröffentlichen. Sie können selbst versuchen, zu sehen, dass es tatsächlich 32 Mal gedruckt wird, und dann, wie aufgrund des Überlaufs erläutert, i = 1073741824 + 1073741824 wechselt zu -2147483648 und eine weitere Addition liegt außerhalb des Bereichs von int und dreht sich zu 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;
}

Der Wert von iwird mit einer festen Anzahl von Binärziffern im Speicher gespeichert. Wenn eine Nummer mehr Ziffern benötigt als verfügbar ist, werden nur die niedrigsten Ziffern gespeichert (die höchsten Ziffern gehen verloren).

Das Hinzufügen izu sich selbst ist dasselbe wie das Multiplizieren imit zwei. Genau wie das Multiplizieren einer Zahl mit zehn in Dezimalschreibweise durch Verschieben jeder Ziffer nach links und Setzen einer Null nach rechts durchgeführt werden kann, kann das Multiplizieren einer Zahl mit zwei in Binärschreibweise auf die gleiche Weise durchgeführt werden. Dadurch wird rechts eine Ziffer hinzugefügt, sodass links eine Ziffer verloren geht.

Hier ist der Startwert 1, wenn wir also 8 Ziffern zum Speichern verwenden i(zum Beispiel),

• Nach 0 Iterationen ist der Wert 00000001
• Nach 1 Iteration ist der Wert 00000010
• Nach 2 Iterationen ist der Wert 00000100

und so weiter bis zum letzten Schritt ungleich Null

• Nach 7 Iterationen ist der Wert 10000000
• Nach 8 Iterationen ist der Wert 00000000

Unabhängig davon, wie viele Binärziffern zum Speichern der Nummer zugewiesen sind und wie hoch der Startwert ist, gehen schließlich alle Ziffern verloren, wenn sie nach links verschoben werden. Wenn Sie die Zahl nach diesem Zeitpunkt weiter verdoppeln, ändert sich die Zahl nicht mehr - sie wird weiterhin durch alle Nullen dargestellt.

Es ist korrekt, aber nach 31 Iterationen berechnet 1073741824 + 1073741824 nicht richtig und gibt danach nur noch 0 aus.

Sie können die Verwendung von BigInteger umgestalten, damit Ihre Endlosschleife ordnungsgemäß funktioniert.

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

Zum Debuggen solcher Fälle empfiehlt es sich, die Anzahl der Iterationen in der Schleife zu reduzieren. Verwenden Sie dies anstelle von while(true):

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

Sie können dann sehen, dass es mit 2 beginnt und den Wert verdoppelt, bis es einen Überlauf verursacht.

Ich werde zur Veranschaulichung eine 8-Bit-Zahl verwenden, da diese in kurzer Zeit vollständig detailliert werden kann. Hex-Zahlen beginnen mit 0x, während Binärzahlen mit 0b beginnen.

Der Maximalwert für eine 8-Bit-Ganzzahl ohne Vorzeichen beträgt 255 (0xFF oder 0b11111111). Wenn Sie 1 hinzufügen, erwarten Sie normalerweise: 256 (0x100 oder 0b100000000). Aber da das zu viele Bits (9) sind, ist das über dem Maximum, so dass der erste Teil einfach gelöscht wird und Sie effektiv 0 haben (0x (1) 00 oder 0b (1) 00000000, aber mit der 1).

Wenn Ihr Programm ausgeführt wird, erhalten Sie:

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

Das größte Dezimalliteral des Typs intist 2147483648 (= 2 ³¹ ). Alle Dezimalliterale von 0 bis 2147483647 können überall dort erscheinen, wo ein int-Literal erscheinen kann, aber das Literal 2147483648 kann nur als Operand des unären Negationsoperators erscheinen -.

Wenn eine ganzzahlige Addition überläuft, sind das Ergebnis die niederwertigen Bits der mathematischen Summe, wie sie in einem ausreichend großen Zweierkomplementformat dargestellt werden. Wenn ein Überlauf auftritt, stimmt das Vorzeichen des Ergebnisses nicht mit dem Vorzeichen der mathematischen Summe der beiden Operandenwerte überein.