İnt i = 1024 * 1024 * 1024 * 1024 neden hatasız derleniyor?

Sınırı int-2147483648 ile 2147483647 arasındadır.

Girersem

int i = 2147483648;

Eclipse "2147483648" altında kırmızı bir alt çizgi isteyecektir.

Ama bunu yaparsam:

int i = 1024 * 1024 * 1024 * 1024;

iyi derlenecektir.

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

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

    }
}

Belki Java'da temel bir soru, ama ikinci varyantın neden hata üretmediği hakkında hiçbir fikrim yok.

Bu ifadede yanlış bir şey yok; sadece 4 rakamı çarpıp bir int'e atarsanız, bir taşma olur. Bu, derleme zamanında sınır denetlenecek tek bir hazır bilgi atamaktan farklıdır .

Bu out-of-sınırları olduğunu değişmezi konusu hatayı değil, neden atama :

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

Bunun aksine bir longdeğişmez para cezası derler:

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

Aslında, sonuç, unutmayın edilir çünkü hala derleme zamanında hesaplanan 1024 * 1024 * 1024 * 1024bir olan sabit ifadesi :

int i = 1024 * 1024 * 1024 * 1024;

dönüşür:

   0: iconst_0      
   1: istore_1      

Sonuçun ( 0) basitçe yüklendiğine ve saklandığına ve çarpma gerçekleşmediğine dikkat edin.

Gönderen JLS §3.10.1 (yorumlar kısmında açtığın için @ChrisK sayesinde):

Ondalık bir ondalık harf türü (2 ³¹ ) ' intden büyükse veya ondalık harf değişkeni tekli eksi operatörünün işleneni dışında bir yerde görünüyorsa , derleme zamanı hatasıdır ( §15.15.4 ).21474836482147483648

1024 * 1024 * 1024 * 1024ve 2147483648Java'da aynı değere sahip değildir.

Aslında, Java'da 2147483648 DEĞER DEĞİLDİR (olmasına rağmen 2147483648L). Derleyici tam olarak ne olduğunu veya nasıl kullanılacağını bilmiyor. Yani şaraplar.

1024Java'da geçerli bir int ve geçerli intbaşka bir geçerli ile çarpılır int, her zaman geçerlidir int. Sezgisel olarak beklediğiniz aynı değer olmasa bile, hesaplama taşacak.

Misal

Aşağıdaki kod örneğini düşünün:

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

Bunun bir derleme hatası oluşturmasını bekler misiniz? Şimdi biraz daha kayganlaşıyor.
Ya 3 yinelemeli bir döngü koyar ve döngüde çoğalırsak?

Derleyicinin optimizasyonuna izin verilir, ancak programın davranışını değiştiremez.

Bu davanın nasıl ele alındığına dair bazı bilgiler:

Java ve diğer birçok dilde, tamsayılar sabit sayıda bitten oluşur. Verilen bit sayısına uymayan hesaplamalar taşacaktır ; hesaplama temelde Java'da 2 ^ 32 modülüdür , bundan sonra değer işaretli bir tamsayıya dönüştürülür .

Diğer diller veya API'ler dinamik sayıda bit kullanır ( BigIntegerJava'da), bir istisna oluşturur veya değeri sayı değil gibi sihirli bir değere ayarlar.

İkinci varyantın neden hata ürettiğini bilmiyorum.

Önerdiğiniz davranış - yani, bir hesaplama bir tamsayıda saklanabilecek en büyük değerden daha büyük bir değer ürettiğinde - tanı mesajının üretilmesi bir özelliktir . Herhangi bir özelliği kullanabilmeniz için, özellik düşünülmeli, iyi bir fikir olarak düşünülmeli, tasarlanmalı, belirlenmeli, uygulanmalı, test edilmeli, belgelenmeli ve kullanıcılara gönderilmelidir.

Java için bu listedeki bir veya daha fazla şey olmadı ve bu nedenle özelliğiniz yok. Hangisini bilmiyorum; bir Java tasarımcısına sormanız gerekir.

C # için, tüm bu şeyler gerçekleşti - yaklaşık on dört yıl önce - ve böylece C #'daki ilgili program C # 1.0'dan beri bir hata üretti.

Arshajii'nin cevabına ek olarak bir şey daha göstermek istiyorum:

Hataya neden olan ödev değil, basitçe literal kullanımıdır . Denediğinde

long i = 2147483648;

sağ taraf hala bir intliteral ve aralık dışında olduğundan bir derleme hatasına neden olduğunu fark edeceksiniz .

Bu nedenle, int-değerli işlemler (ve atamalar dahil) bir derleme hatası olmadan (ve bir çalışma zamanı hatası olmadan) taşabilir, ancak derleyici bu çok büyük değişmezleri işleyemez.

C: Çünkü bu bir hata değil.

Arka plan: Çarpma 1024 * 1024 * 1024 * 1024bir taşmaya neden olur. Taşma genellikle bir hatadır. Farklı programlama dilleri taşmalar meydana geldiğinde farklı davranışlar üretir. Örneğin, C ve C ++ imzalı tamsayılar için "tanımsız davranış" olarak adlandırır ve davranış imzasız tamsayı olarak tanımlanır (matematiksel sonucu alın, UINT_MAX + 1sonuç negatif olduğu sürece ekleyin , sonuç büyük UINT_MAX + 1olduğu sürece çıkarın UINT_MAX).

Java durumunda, intdeğerler içeren bir işlemin sonucu izin verilen aralıkta değilse, kavramsal olarak Java, sonuç izin verilen aralıkta olana kadar 2 ^ 32 ekler veya çıkarır. Dolayısıyla ifade tamamen yasaldır ve hatalı değildir. Sadece umduğunuz sonucu vermiyor.

Bu davranışın yardımcı olup olmadığını ve derleyicinin size bir uyarı vermesi gerekip gerekmediğini kesinlikle tartışabilirsiniz. Şahsen bir uyarının çok yararlı olacağını söyleyebilirim, ancak yasal Java olduğu için bir hata yanlış olur.