Почему i = i + i дает мне 0?

У меня простая программа:

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

Когда я запускаю эту программу, все , что я вижу 0на iв моем выходе. Я ожидал, что в первый раз у нас будет i = 1 + 1, а i = 2 + 2затем и i = 4 + 4т. Д.

Это связано с тем, что, как только мы пытаемся повторно объявить iслева, его значение сбрасывается до 0?

Если бы кто-нибудь мог указать мне более тонкие детали этого, это было бы здорово.

Измените значение intна, longи кажется, что числа печатаются должным образом. Я удивлен, насколько быстро он достигает максимального 32-битного значения!

Проблема связана с целочисленным переполнением.

В 32-битной арифметике с двоичным дополнением:

iдействительно начинает иметь значения степени двойки, но затем начинается поведение переполнения, когда вы дойдете до 2 ³⁰ :

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

-2 ³¹ + -2 ³¹ = 0

... в intарифметике, поскольку это по существу арифметический модуль 2 ^ 32.

Введение

Проблема в целочисленном переполнении. Если он переполняется, он возвращается к минимальному значению и продолжается оттуда. Если он становится недостаточным, он возвращается к максимальному значению и продолжается оттуда. На изображении ниже показан одометр. Я использую это для объяснения переполнения. Это механический переполнение, но все же хороший пример.

В одометре, max digit = 9превышение максимального означает 9 + 1, что переносится и дает 0; Однако нет более высокой цифры, которую можно было бы изменить на a 1, поэтому счетчик сбрасывается на zero. Вы уловили идею - сейчас на ум приходят «целочисленные переполнения».

Самый большой десятичный литерал типа int - 2147483647 (2 ³¹ -1). Все десятичные литералы от 0 до 2147483647 могут появляться везде, где может появиться литерал int, но литерал 2147483648 может появляться только как операнд унарного оператора отрицания -.

Если при целочисленном сложении происходит переполнение, то результатом являются младшие биты математической суммы, представленные в некотором достаточно большом формате с дополнением до двух. Если происходит переполнение, то знак результата не совпадает со знаком математической суммы двух значений операндов.

Таким образом, 2147483647 + 1переполняется и оборачивается -2147483648. Следовательно int i=2147483647 + 1, будет переполнено, что не равно 2147483648. Кроме того, вы говорите «он всегда печатает 0». Это не так, потому что http://ideone.com/WHrQIW . Ниже эти 8 чисел показывают точку, в которой он вращается и переполняется. Затем он начинает печатать нули. Кроме того, не удивляйтесь, насколько быстро он вычисляет, современные машины быстры.

268435456
536870912
1073741824
-2147483648
0
0
0
0

Почему целочисленное переполнение "оборачивается"

^{Исходный PDF}

Нет, он не печатает только нули.

Измените его на это, и вы увидите, что произойдет.

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

То, что происходит, называется переполнением.

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

вывод:

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

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

Поскольку у меня недостаточно репутации, я не могу опубликовать изображение вывода для той же программы на C с контролируемым выводом, вы можете попробовать себя и убедиться, что он действительно печатает 32 раза, а затем, как объяснялось, из-за переполнения i = 1073741824 + 1073741824 изменяется на -2147483648 и еще одно добавление выходит за пределы диапазона int и превращается в 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;
}

Значение iхранится в памяти с использованием фиксированного количества двоичных цифр. Когда для числа требуется больше цифр, чем доступно, сохраняются только самые низкие цифры (самые высокие цифры теряются).

Сложение iс собой - это то же самое, что умножение iна два. Точно так же, как умножение числа на десять в десятичной системе счисления можно выполнить, сдвигая каждую цифру влево и ставя ноль справа, умножение числа на два в двоичной системе счисления может выполняться таким же образом. Это добавляет одну цифру справа, поэтому цифра теряется слева.

Здесь начальное значение равно 1, поэтому, если мы используем 8 цифр для хранения i(например),

• после 0 итераций значение равно 00000001
• после 1 итерации значение равно 00000010
• после 2 итераций значение равно 00000100

и так до последнего ненулевого шага

• после 7 итераций значение 10000000
• после 8 итераций значение равно 00000000

Независимо от того, сколько двоичных цифр выделено для хранения числа и независимо от начального значения, в конечном итоге все цифры будут потеряны, поскольку они смещены влево. После этого продолжение удвоения числа не изменит число - оно все равно будет представлено всеми нулями.

Это правильно, но после 31 итерации 1073741824 + 1073741824 вычисляет некорректно и после этого выводит только 0.

Вы можете выполнить рефакторинг для использования BigInteger, чтобы ваш бесконечный цикл работал правильно.

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

Для отладки таких случаев полезно уменьшить количество итераций в цикле. Используйте это вместо своего while(true):

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

Затем вы можете видеть, что он начинается с 2 и удваивает значение, пока не вызовет переполнение.

Я буду использовать 8-битное число для иллюстрации, потому что его можно полностью подробно описать в коротком месте. Шестнадцатеричные числа начинаются с 0x, а двоичные - с 0b.

Максимальное значение для 8-битного целого числа без знака - 255 (0xFF или 0b11111111). Если вы добавите 1, вы обычно ожидаете получить: 256 (0x100 или 0b100000000). Но поскольку это слишком много бит (9), это превышает максимум, поэтому первая часть просто отбрасывается, оставляя вам фактически 0 (0x (1) 00 или 0b (1) 00000000, но с отброшенным 1).

Итак, когда ваша программа запускается, вы получаете:

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

Самый большой десятичный литерал типа int- 2147483648 (= 2 ³¹ ). Все десятичные литералы от 0 до 2147483647 могут появляться везде, где может появиться литерал int, но литерал 2147483648 может появляться только как операнд унарного оператора отрицания -.

Если целочисленное сложение переполняется, результатом являются младшие биты математической суммы, представленные в некотором достаточно большом формате с дополнением до двух. Если происходит переполнение, то знак результата не совпадает со знаком математической суммы двух значений операндов.