Mengapa i = i + i memberi saya 0?

Saya memiliki program sederhana:

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

Ketika saya menjalankan program ini, yang saya lihat hanyalah 0untuk ioutput saya. Saya akan mengharapkan putaran pertama kami akan i = 1 + 1, diikuti oleh i = 2 + 2, diikuti oleh i = 4 + 4dll.

Apakah ini karena fakta bahwa segera setelah kami mencoba mendeklarasikan ulang idi sisi kiri, nilainya disetel ulang ke 0?

Jika ada yang bisa menunjukkan saya ke detail yang lebih baik dari ini, itu akan bagus.

Ubah intmenjadi longdan tampaknya mencetak nomor seperti yang diharapkan. Saya terkejut betapa cepatnya mencapai nilai maksimal 32-bit!

Masalahnya adalah karena kelebihan bilangan bulat.

Dalam aritmatika pelengkap dua 32-bit:

imemang mulai memiliki nilai kekuatan dua, tetapi kemudian perilaku luapan dimulai begitu Anda mencapai 2 ³⁰ :

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

-2 ³¹ + -2 ³¹ = 0

... dalam intaritmatika, karena pada dasarnya ini adalah mod aritmatika 2 ^ 32.

pengantar

Masalahnya adalah integer overflow. Jika meluap, nilai kembali ke nilai minimum dan berlanjut dari sana. Jika tidak mengalir, nilai kembali ke nilai maksimum dan berlanjut dari sana. Gambar di bawah ini adalah Odometer. Saya menggunakan ini untuk menjelaskan overflow. Ini adalah luapan mekanis tetapi masih merupakan contoh yang bagus.

Dalam sebuah Odometer, max digit = 9itu melampaui sarana maksimum 9 + 1, yang membawa dan memberikan 0; Namun tidak ada digit yang lebih tinggi untuk diubah menjadi a 1, sehingga penghitung diatur ulang ke zero. Anda mendapatkan ide - "integer overflows" muncul di benak Anda sekarang.

Literal desimal terbesar dari tipe int adalah 2147483647 (2 ³¹ -1). Semua literal desimal dari 0 hingga 2147483647 dapat muncul di mana pun literal int dapat muncul, tetapi literal 2147483648 hanya dapat muncul sebagai operan operator negasi unary -.

Jika penjumlahan bilangan bulat meluap, maka hasilnya adalah bit orde rendah dari jumlah matematis seperti yang direpresentasikan dalam beberapa format komplemen dua yang cukup besar. Jika terjadi overflow, maka tanda hasil tidak sama dengan tanda penjumlahan matematis dari kedua nilai operan.

Dengan demikian, 2147483647 + 1melimpah dan membungkus -2147483648. Karenanya int i=2147483647 + 1akan meluap, yang tidak sama dengan 2147483648. Selain itu, Anda mengatakan "selalu mencetak 0". Tidak, karena http://ideone.com/WHrQIW . Di bawah, 8 angka ini menunjukkan titik di mana ia berputar dan meluap. Kemudian mulai mencetak 0s. Juga, jangan heran betapa cepatnya menghitung, mesin-mesin saat ini sangat cepat.

268435456
536870912
1073741824
-2147483648
0
0
0
0

Mengapa integer overflow "membungkus"

^{PDF asli}

Tidak, ini tidak hanya mencetak angka nol.

Ubah ke ini dan Anda akan melihat apa yang terjadi.

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

Apa yang terjadi disebut overflow.

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

out put:

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

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

Karena saya tidak memiliki cukup reputasi, saya tidak dapat memposting gambar output untuk program yang sama di C dengan output terkontrol, Anda dapat mencoba sendiri dan melihat bahwa itu benar-benar mencetak 32 kali dan kemudian seperti yang dijelaskan karena luapan i = 1073741824 + 1073741824 berubah menjadi -2147483648 dan satu tambahan lagi berada di luar jangkauan int dan berubah menjadi 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;
}

Nilai idisimpan dalam memori menggunakan jumlah digit biner yang tetap. Ketika suatu angka membutuhkan lebih banyak digit daripada yang tersedia, hanya digit terendah yang disimpan (digit tertinggi hilang).

Menjumlahkan idirinya sendiri sama dengan mengalikan idua. Sama seperti mengalikan angka dengan sepuluh dalam notasi desimal dapat dilakukan dengan menggeser setiap digit ke kiri dan meletakkan nol di kanan, mengalikan angka dengan dua dalam notasi biner dapat dilakukan dengan cara yang sama. Ini menambahkan satu digit di kanan, jadi satu digit hilang di sebelah kiri.

Di sini nilai awalnya adalah 1, jadi jika kita menggunakan 8 digit untuk menyimpan i(misalnya),

• setelah 0 iterasi, nilainya adalah 00000001
• setelah 1 iterasi, nilainya adalah 00000010
• setelah 2 iterasi, nilainya adalah 00000100

dan seterusnya, sampai langkah bukan nol terakhir

• setelah 7 iterasi, nilainya adalah 10000000
• setelah 8 iterasi, nilainya adalah 00000000

Tidak peduli berapa banyak digit biner yang dialokasikan untuk menyimpan nomor tersebut, dan tidak peduli berapa nilai awalnya, pada akhirnya semua digit akan hilang saat didorong ke kiri. Setelah itu, terus menggandakan angka tidak akan mengubah angka - angka tersebut akan tetap diwakili oleh semua nol.

Benar, tetapi setelah 31 iterasi, 1073741824 + 1073741824 tidak menghitung dengan benar dan setelah itu hanya mencetak 0.

Anda dapat melakukan refactor untuk menggunakan BigInteger, sehingga infinite loop Anda akan berfungsi dengan benar.

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

Untuk men-debug kasus seperti itu, sebaiknya kurangi jumlah iterasi dalam loop. Gunakan ini sebagai ganti while(true):

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

Anda kemudian dapat melihat bahwa itu dimulai dengan 2 dan menggandakan nilainya hingga menyebabkan luapan.

Saya akan menggunakan angka 8-bit untuk ilustrasi karena dapat dirinci sepenuhnya dalam waktu singkat. Bilangan hex dimulai dengan 0x, sedangkan bilangan biner dimulai dengan 0b.

Nilai maksimal untuk bilangan bulat unsigned 8-bit adalah 255 (0xFF atau 0b11111111). Jika Anda menambahkan 1, biasanya Anda akan mendapatkan: 256 (0x100 atau 0b100000000). Tetapi karena itu terlalu banyak bit (9), itu melebihi batas maksimum, jadi bagian pertama akan dibuang, meninggalkan Anda dengan 0 efektif (0x (1) 00 atau 0b (1) 00000000, tetapi dengan 1 dijatuhkan).

Jadi, saat program Anda berjalan, Anda mendapatkan:

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

Literal desimal terbesar untuk jenis intini adalah 2147483648 (= 2 ³¹ ). Semua literal desimal dari 0 hingga 2147483647 dapat muncul di mana pun literal int mungkin muncul, tetapi literal 2147483648 hanya dapat muncul sebagai operan operator negasi unary -.

Jika penjumlahan bilangan bulat meluap, maka hasilnya adalah bit orde rendah dari jumlah matematis seperti yang direpresentasikan dalam beberapa format komplemen dua yang cukup besar. Jika terjadi overflow, maka tanda hasil tidak sama dengan tanda penjumlahan matematis dari kedua nilai operan.