ทำไม 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ปรากฏขึ้นที่อื่นนอกเหนือจากตัวถูกดำเนินการของผู้ประกอบการ unary ลบ ( §15.15.4 )

1024 * 1024 * 1024 * 1024และ2147483648ไม่มีค่าเดียวกันใน Java

ที่จริงแล้ว2147483648 ไม่ใช่ค่า (แม้ว่าจะ2147483648Lเป็น) ใน Java คอมไพเลอร์แท้จริงไม่ทราบว่ามันคืออะไรหรือวิธีการใช้งาน ดังนั้นมันจึงสะอื้น

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

นอกจากคำตอบของ arshajii ฉันต้องการแสดงอีกอย่าง:

มันไม่ได้เป็นที่ได้รับมอบหมายที่ทำให้เกิดข้อผิดพลาด แต่เพียงการใช้งานของตัวอักษร เมื่อคุณลอง

long i = 2147483648;

คุณจะสังเกตเห็นว่ามันยังทำให้เกิดข้อผิดพลาดในการคอมไพล์เนื่องจากทางด้านขวายังคงเป็นint-literal และอยู่นอกช่วง

ดังนั้นการดำเนินการด้วย - intค่า (และที่รวมถึงการมอบหมาย) อาจล้นโดยไม่มีข้อผิดพลาดในการคอมไพล์ (และไม่มีข้อผิดพลาดรันไทม์เช่นกัน) แต่คอมไพเลอร์ก็ไม่สามารถจัดการตัวอักษรที่มีขนาดใหญ่เกินไป

ตอบ:ไม่ใช่ข้อผิดพลาด

ความเป็นมา:การคูณ1024 * 1024 * 1024 * 1024จะนำไปสู่การล้น การโอเวอร์โฟลว์มักเป็นจุดบกพร่อง ภาษาการเขียนโปรแกรมที่แตกต่างกันจะมีพฤติกรรมที่แตกต่างกัน ตัวอย่างเช่น C และ C ++ เรียกมันว่า "พฤติกรรมที่ไม่ได้กำหนด" สำหรับจำนวนเต็มที่ลงนามและพฤติกรรมนั้นถูกกำหนดไว้เป็นจำนวนเต็มที่ไม่ได้ลงชื่อ (รับผลทางคณิตศาสตร์เพิ่มUINT_MAX + 1ตราบใดที่ผลเป็นลบลบUINT_MAX + 1ตราบใดที่ผลมีค่ามากกว่าUINT_MAX)

ในกรณีของ Java หากผลลัพธ์ของการดำเนินการที่มีintค่าไม่อยู่ในช่วงที่อนุญาต Java จะเพิ่มหรือลบแนวคิด 2 ^ 32 จนกว่าผลลัพธ์จะอยู่ในช่วงที่อนุญาต ดังนั้นคำสั่งนั้นถูกกฎหมายอย่างสมบูรณ์และไม่ผิดพลาด มันไม่ได้สร้างผลลัพธ์ที่คุณคาดหวังไว้

คุณสามารถยืนยันได้ว่าพฤติกรรมนี้มีประโยชน์หรือไม่และผู้รวบรวมควรให้คำเตือนหรือไม่ ฉันจะบอกเป็นการส่วนตัวว่าคำเตือนจะมีประโยชน์มาก แต่ข้อผิดพลาดจะไม่ถูกต้องเนื่องจากเป็นจาวาที่ถูกกฎหมาย