Чому int i = 1024 * 1024 * 1024 * 1024 компілюється без помилок?

Ліміт int- від -2147483648 до 2147483647.

Якщо я ввожу

int i = 2147483648;

тоді Eclipse підкаже червоне підкреслення під "2147483648".

Але якщо я це роблю:

int i = 1024 * 1024 * 1024 * 1024;

це складе штрафи.

public class Test {
    public static void main(String[] args) {        

        int i = 2147483648;                   // error
        int j = 1024 * 1024 * 1024 * 1024;    // no error

    }
}

Можливо, це основне питання в Java, але я не маю поняття, чому другий варіант не створює помилок.

У цьому твердженні нічого поганого; ви просто перемножуєте 4 числа і присвоюєте його до int, просто трапляється переповнення. Це інакше, ніж присвоєння єдиного літералу , який би перевірявся межею під час компіляції.

Саме літерал поза межами викликає помилку, а не призначення :

System.out.println(2147483648);        // error
System.out.println(2147483647 + 1);    // no error

На відміну від цього, longбуквальне значення складе:

System.out.println(2147483648L);       // no error

Зауважте, що насправді результат все ж обчислюється під час компіляції, оскільки 1024 * 1024 * 1024 * 1024це постійний вираз :

int i = 1024 * 1024 * 1024 * 1024;

стає:

   0: iconst_0      
   1: istore_1      

Зауважте, що результат ( 0) просто завантажується і зберігається, і множення не відбувається.

З розділу JLS §3.10.1 (спасибі @ChrisK за те, що він виклав це у коментарях):

Це помилка часу компіляції, якщо десятковий буквальний тип intбільше 2147483648(2 ³¹ ), або якщо десяткова буквальна 2147483648з’являється деінде, ніж як операнд оператора унарного мінусу ( §15.15.4 ).

1024 * 1024 * 1024 * 1024і 2147483648не мають однакового значення на Java.

Насправді, В 2147483648 ЯВІ НЕ БУДЕ ЦІННА (хоча 2147483648Lє). Компілятор буквально не знає, що це таке, або як ним користуватися. Так воно скуголить.

1024є дійсним int на Java, а дійсний, intпомножений на інший дійсний int, завжди є дійсним int. Навіть якщо це не те саме значення, яке ви б інтуїтивно очікували, оскільки обчислення переповниться.

Приклад

Розглянемо наступний зразок коду:

public static void main(String[] args) {
    int a = 1024;
    int b = a * a * a * a;
}

Чи очікуєте ви, що це призведе до помилки компіляції? Це стає трохи більш слизьким.
Що робити, якщо ми помістимо цикл з 3 ітераціями і помножимо на циклі?

Компілятору дозволено оптимізувати, але він не може змінити поведінку програми під час цього.

Деякі відомості про те, як насправді ведеться ця справа:

У Java та багатьох інших мовах цілі числа будуть складатися з фіксованої кількості бітів. Розрахунки, які не вписуються в задану кількість біт, переповняться ; обчислення в основному виконується модулем 2 ^ 32 в Java, після чого значення перетворюється назад у підписане ціле число.

Інші мови чи API використовують динамічне число біт ( BigIntegerна Java), підвищують виняток або встановлюють значення на магічне значення, наприклад, не-а-число.

Я поняття не маю, чому другий варіант не дає помилок.

Поведінка, яку ви пропонуєте - тобто виготовлення діагностичного повідомлення, коли обчислення виробляють значення, яке більше, ніж найбільше значення, яке може бути збережене в цілому цілому - є особливістю . Щоб ви могли використовувати будь-яку функцію, цю функцію слід продумати, вважати її хорошою ідеєю, розробити, уточнити, реалізувати, протестувати, задокументувати та відправити користувачам.

Для Java однієї або декількох речей у цьому списку не відбулося, і тому у вас немає цієї функції. Я не знаю, який з них; вам доведеться запитати дизайнера Java.

Що стосується C #, все це сталося - близько чотирнадцяти років тому - і відповідна програма в C # виникла помилку після C # 1.0.

Окрім відповіді аршаджі, я хочу ще одне:

Помилка викликає не призначення , а просто використання літералу . Коли ви намагаєтесь

long i = 2147483648;

ви помітите, що це також спричиняє помилку компіляції, оскільки права частина все ще є int-літеральною та поза діапазоном.

Таким чином, операції з int-values ​​(і це включає в себе призначення) можуть переповнюватися без помилки компіляції (і без помилки виконання), але компілятор просто не може обробити ці занадто великі літерали.

Відповідь: Тому що це не помилка.

Передумови: Множення 1024 * 1024 * 1024 * 1024призведе до переповнення. Переповнення дуже часто є помилкою. Різні мови програмування викликають різну поведінку, коли відбувається переповнення. Наприклад, C і C ++ називають це "невизначеною поведінкою" для підписаних цілих чисел, а поведінка визначається непідписаними цілими числами (візьміть математичний результат, додайте до UINT_MAX + 1тих пір, поки результат негативний, відніміть UINT_MAX + 1, поки результат більший, ніж результат UINT_MAX).

У випадку з Java, якщо результат операції зі intзначеннями не знаходиться в дозволеному діапазоні, концептуально Java додає або віднімає 2 ^ 32, поки результат не буде в допустимому діапазоні. Тож заява є повністю законною і не помиляється. Це просто не дає результату, на який ви могли сподіватися.

Ви напевно можете заперечити, чи корисна ця поведінка та чи повинен компілятор надати вам попередження. Я б особисто сказав, що попередження було б дуже корисним, але помилка була б невірною, оскільки це легальна Java.