การแสดงออกของ C # ลอย: พฤติกรรมแปลก ๆ เมื่อส่งผลลอยไปยัง int

ฉันมีรหัสง่ายๆดังต่อไปนี้:

int speed1 = (int)(6.2f * 10);
float tmp = 6.2f * 10;
int speed2 = (int)tmp;

speed1และspeed2ควรมีค่าเท่ากัน แต่อันที่จริงฉันมี:

speed1 = 61
speed2 = 62

ฉันรู้ว่าฉันควรใช้ Math.Round แทนการคัดเลือกนักแสดง แต่ฉันต้องการที่จะเข้าใจว่าทำไมค่าต่างกัน

ฉันดูโค้ดไบต์ที่สร้างขึ้น แต่ยกเว้นร้านค้าและโหลด opcodes เหมือนกัน

ฉันยังลองรหัสเดียวกันใน java และฉันได้รับ 62 และ 62 อย่างถูกต้อง

มีคนอธิบายเรื่องนี้ได้ไหม

แก้ไข: ในรหัสจริงมันไม่ได้โดยตรง 6.2f * 10 แต่ฟังก์ชั่นการโทร * ค่าคงที่ ฉันมีรหัสไบต์ต่อไปนี้:

สำหรับspeed1:

IL_01b3:  ldloc.s    V_8
IL_01b5:  callvirt   instance float32 myPackage.MyClass::getSpeed()
IL_01ba:  ldc.r4     10.
IL_01bf:  mul
IL_01c0:  conv.i4
IL_01c1:  stloc.s    V_9

สำหรับspeed2:

IL_01c3:  ldloc.s    V_8
IL_01c5:  callvirt   instance float32 myPackage.MyClass::getSpeed()
IL_01ca:  ldc.r4     10.
IL_01cf:  mul
IL_01d0:  stloc.s    V_10
IL_01d2:  ldloc.s    V_10
IL_01d4:  conv.i4
IL_01d5:  stloc.s    V_11

stloc/ldlocเราสามารถมองเห็นตัวถูกดำเนินการที่มีลอยและที่แตกต่างเพียงอย่างเดียวคือ

สำหรับเครื่องเสมือนฉันลองกับ Mono / Win7, Mono / MacOS และ. NET / Windows ด้วยผลลัพธ์เดียวกัน

ก่อนอื่นฉันคิดว่าคุณรู้ว่า6.2f * 10ไม่ใช่ 62 อย่างแน่นอนเนื่องจากการปัดเศษทศนิยม (จริง ๆ แล้วมีค่า 61.99999809265137 เมื่อแสดงเป็น a double) และคำถามของคุณเป็นเพียงว่าทำไมการคำนวณเหมือนกันสองครั้งจึงทำให้ค่าผิด

คำตอบคือในกรณีของ(int)(6.2f * 10)คุณจะใช้doubleค่า 61.99999809265137 และตัดให้เป็นจำนวนเต็มซึ่งให้ผล 61

ในกรณีของfloat f = 6.2f * 10คุณจะใช้ค่าสองครั้ง 61.99999809265137 และปัดเศษเป็นค่าที่ใกล้ที่สุดfloatซึ่งก็คือ 62 จากนั้นคุณตัดทอนfloatให้เป็นจำนวนเต็มและผลลัพธ์คือ 62

แบบฝึกหัด: อธิบายผลลัพธ์ของลำดับการปฏิบัติการต่อไปนี้

double d = 6.2f * 10;
int tmp2 = (int)d;
// evaluate tmp2

ปรับปรุง: ตามที่ระบุไว้ในความคิดเห็นที่แสดงออก6.2f * 10เป็นอย่างเป็นทางการfloatตั้งแต่พารามิเตอร์ที่สองมีการแปลงส่อไปfloatซึ่งเป็นที่ดีขึ้นdoubleกว่าการแปลงนัยไป

ปัญหาที่เกิดขึ้นจริงคือว่าคอมไพเลอร์จะได้รับอนุญาต ( แต่ไม่จำเป็น) เพื่อใช้เป็นสื่อกลางซึ่งเป็นที่มีความแม่นยำสูงกว่าประเภทอย่างเป็นทางการ (มาตรา 11.2.2) นั่นเป็นเหตุผลที่คุณเห็นพฤติกรรมที่แตกต่างกันในระบบที่แตกต่างกันในการแสดงออก(int)(6.2f * 10)คอมไพเลอร์มีตัวเลือกในการรักษาค่าในรูปแบบที่เป็นสื่อกลางความแม่นยำสูงก่อนการแปลง6.2f * 10 intหากเป็นเช่นนั้นผลลัพธ์จะเป็น 61 หากไม่เป็นเช่นนั้นผลที่ได้คือ 62

ในตัวอย่างที่สองการมอบหมายอย่างชัดเจนเพื่อfloatบังคับให้การปัดเศษเกิดขึ้นก่อนการแปลงเป็นจำนวนเต็ม

ลักษณะ

ตัวเลขลอยตัวไม่ค่อยแน่นอน เป็นสิ่งที่ต้องการ6.2f 6.1999998...หากคุณส่งไปยัง int มันจะตัดทอนมันและ * 10 ผลลัพธ์ใน 61

ตรวจสอบDoubleConverterคลาสJon Skeets ด้วยคลาสนี้คุณสามารถเห็นภาพค่าตัวเลขลอยตัวเป็นสตริงได้ Doubleและfloatเป็นทั้งตัวเลขลอยตัวทศนิยมไม่ใช่ (มันเป็นหมายเลขจุดคงที่)

ตัวอย่าง

DoubleConverter.ToExactString((6.2f * 10))
// output 61.9999980926513671875

ข้อมูลมากกว่านี้

• คลาส DoubleConverter ของ Jon Skeet
• Assert.AreEqual () กับ System.Double ทำให้สับสนจริงๆ
• สิ่งที่นักวิทยาศาสตร์คอมพิวเตอร์ทุกคนควรรู้เกี่ยวกับเลขคณิตทศนิยม

ดู IL:

IL_0000:  ldc.i4.s    3D              // speed1 = 61
IL_0002:  stloc.0
IL_0003:  ldc.r4      00 00 78 42     // tmp = 62.0f
IL_0008:  stloc.1
IL_0009:  ldloc.1
IL_000A:  conv.i4
IL_000B:  stloc.2

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

ฉันเดาว่า6.2fเป็นตัวแทนที่แท้จริงที่มีความแม่นยำลอยคือ6.1999999ในขณะที่อาจจะเป็นสิ่งที่คล้ายกับ62f การคัดเลือกจะตัดทอนค่าทศนิยมเสมอเพื่อให้คุณได้รับพฤติกรรมนั้น62.00000001(int)

แก้ไข : ตามความคิดเห็นที่ฉันได้ rephrased พฤติกรรมของintการคัดเลือกที่มีความแม่นยำมากขึ้น

ฉันรวบรวมและถอดรหัสนี้ (บน Win7 / .NET 4.0) ฉันเดาว่าคอมไพเลอร์ประเมินนิพจน์คงที่แบบลอยตัวเป็นสองเท่า

int speed1 = (int)(6.2f * 10);
   mov         dword ptr [rbp+8],3Dh       //result is precalculated (61)

float tmp = 6.2f * 10;
   movss       xmm0,dword ptr [000004E8h]  //precalculated (float format, xmm0=0x42780000 (62.0))
   movss       dword ptr [rbp+0Ch],xmm0 

int speed2 = (int)tmp;
   cvttss2si   eax,dword ptr [rbp+0Ch]     //instrunction converts float to Int32 (eax=62)
   mov         dword ptr [rbp+10h],eax 

Singlemantains เพียง 7 หลักและเมื่อส่งไปInt32ยังคอมไพเลอร์จะตัดทอนตัวเลขทศนิยมทั้งหมด ในระหว่างการแปลงหนึ่งหลักที่สำคัญอาจสูญหายได้

Int32 speed0 = (Int32)(6.2f * 100000000); 

ให้ผลลัพธ์ของ 619999980 ดังนั้น (Int32) (6.2f * 10) ให้ 61

มันแตกต่างกันเมื่อสอง Single ถูกคูณในกรณีนั้นไม่มีการดำเนินการที่ถูกตัดทอน แต่ประมาณเท่านั้น

ดูhttp://msdn.microsoft.com/en-us/library/system.single.aspx

มีเหตุผลที่คุณพิมพ์แบบหล่อintแทนการแยกวิเคราะห์หรือไม่?

int speed1 = (int)(6.2f * 10)

ก็จะอ่าน

int speed1 = Int.Parse((6.2f * 10).ToString()); 

ความแตกต่างน่าจะเกี่ยวกับการปัดเศษ: ถ้าคุณโยนไป doubleคุณอาจจะได้อะไรแบบ 61.78426

โปรดทราบผลลัพธ์ต่อไปนี้

int speed1 = (int)(6.2f * 10);//61
double speed2 = (6.2f * 10);//61.9999980926514

นั่นคือเหตุผลที่คุณได้รับคุณค่าที่แตกต่าง!