Perché int i = 1024 * 1024 * 1024 * 1024 si compila senza errori?

Il limite intè compreso tra -2147483648 e 2147483647.

Se inserisco

int i = 2147483648;

quindi Eclipse richiederà una sottolineatura rossa in "2147483648".

Ma se lo faccio:

int i = 1024 * 1024 * 1024 * 1024;

compilerà bene.

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

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

    }
}

Forse è una domanda di base in Java, ma non ho idea del perché la seconda variante non produca errori.

Non c'è niente di sbagliato in questa affermazione; stai solo moltiplicando 4 numeri e assegnandoli a un int, c'è semplicemente un overflow. Ciò è diverso dall'assegnare un singolo valore letterale , che verrebbe controllato al limite in fase di compilazione.

È il letterale fuori limite che causa l'errore, non l' assegnazione :

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

Al contrario un longletterale compilerebbe bene:

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

Si noti che, in effetti, il risultato viene comunque calcolato in fase di compilazione perché 1024 * 1024 * 1024 * 1024è un'espressione costante :

int i = 1024 * 1024 * 1024 * 1024;

diventa:

   0: iconst_0      
   1: istore_1      

Si noti che il risultato ( 0) viene semplicemente caricato e memorizzato e non si verifica alcuna moltiplicazione.

Da JLS §3.10.1 (grazie a @ChrisK per averlo riportato nei commenti):

È un errore in fase di compilazione se un valore letterale decimale di tipo intè maggiore di 2147483648(2 ³¹ ) o se il valore letterale decimale 2147483648appare in qualsiasi luogo diverso dall'operando dell'operatore meno unario ( §15.15.4 ).

1024 * 1024 * 1024 * 1024e 2147483648non hanno lo stesso valore in Java.

In realtà, 2147483648 NON È ANCHE UN VALORE (anche se lo 2147483648Lè) in Java. Il compilatore non sa letteralmente di cosa si tratta o come utilizzarlo. Quindi si lamenta.

1024è un int valido in Java e un valido intmoltiplicato per un altro valido intè sempre valido int. Anche se non è lo stesso valore che ti aspetteresti intuitivamente perché il calcolo trabocca.

Esempio

Si consideri il seguente esempio di codice:

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

Ti aspetti che ciò generi un errore di compilazione? Ora diventa un po 'più scivoloso.
E se mettessimo un loop con 3 iterazioni e moltiplicassimo nel loop?

Il compilatore può ottimizzare, ma non può modificare il comportamento del programma mentre lo fa.

Alcune informazioni su come viene gestito questo caso:

In Java e in molte altre lingue, i numeri interi saranno costituiti da un numero fisso di bit. I calcoli che non rientrano nel dato numero di bit verranno traboccati ; il calcolo viene effettuato fondamentalmente modulo 2 ^ 32 in Java, dopo che il valore è tornato convertito in un firmata intero.

Altre lingue o API usano un numero dinamico di bit ( BigIntegerin Java), generano un'eccezione o impostano il valore su un valore magico come non-un-numero.

Non ho idea del perché la seconda variante non produca errori.

Il comportamento suggerito, ovvero la produzione di un messaggio diagnostico quando un calcolo produce un valore maggiore del valore più grande che può essere archiviato in un numero intero , è una funzione . Per poter utilizzare qualsiasi funzione, la funzione deve essere considerata, considerata una buona idea, progettata, specificata, implementata, testata, documentata e spedita agli utenti.

Per Java, una o più delle cose in quella lista non sono successe e quindi non hai la funzione. Non so quale; dovresti chiedere a un designer Java.

Per C #, tutte queste cose sono successe - circa quattordici anni fa ormai - e quindi il programma corrispondente in C # ha prodotto un errore da C # 1.0.

Oltre alla risposta di Arshajii, voglio mostrare un'altra cosa:

Non è il compito che causa l'errore ma semplicemente l'uso del letterale . Quando ci provi

long i = 2147483648;

noterai che provoca anche un errore di compilazione poiché il lato destro è ancora int-literale e fuori portata.

Quindi le operazioni con int-valori (e che includono le assegnazioni) possono traboccare senza un errore di compilazione (e senza un errore di runtime), ma il compilatore non può gestire quei letterali troppo grandi.

A: Perché non è un errore.

Sfondo: la moltiplicazione 1024 * 1024 * 1024 * 1024porterà ad un overflow. Un overflow è molto spesso un bug. Diversi linguaggi di programmazione producono comportamenti diversi quando si verificano overflow. Ad esempio, C e C ++ lo chiamano "comportamento indefinito" per numeri interi con segno, e il comportamento è definito numeri interi senza segno (prendere il risultato matematico, aggiungere UINT_MAX + 1finché il risultato è negativo, sottrarre UINT_MAX + 1finché il risultato è maggiore di UINT_MAX).

Nel caso di Java, se il risultato di un'operazione con intvalori non è compreso nell'intervallo consentito, concettualmente Java aggiunge o sottrae 2 ^ 32 fino a quando il risultato non rientra nell'intervallo consentito. Quindi la dichiarazione è completamente legale e non in errore. Semplicemente non produce il risultato che potresti aver sperato.

Puoi sicuramente discutere se questo comportamento è utile e se il compilatore dovrebbe darti un avvertimento. Direi personalmente che un avviso sarebbe molto utile, ma un errore sarebbe errato poiché è Java legale.