Biểu thức float C #: hành vi lạ khi truyền kết quả float vào int

Tôi có mã đơn giản sau:

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

speed1và speed2nên có cùng giá trị, nhưng thực tế, tôi có:

speed1 = 61
speed2 = 62

Tôi biết có lẽ tôi nên sử dụng Math.Round thay vì truyền, nhưng tôi muốn hiểu tại sao các giá trị lại khác nhau.

Tôi đã xem mã byte được tạo, nhưng ngoại trừ một cửa hàng và tải, các opcode đều giống nhau.

Tôi cũng đã thử mã tương tự trong java và tôi đã nhận được chính xác 62 và 62.

Ai đó có thể giải thích điều này?

Chỉnh sửa: Trong mã thực, nó không trực tiếp 6.2f * 10 mà là một hàm gọi * một hằng số. Tôi có mã byte sau:

cho 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

cho 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

chúng ta có thể thấy rằng toán hạng là số float và sự khác biệt duy nhất là stloc/ldloc.

Đối với máy ảo, tôi đã thử với Mono / Win7, Mono / MacOS và .NET / Windows, với kết quả tương tự.

Trước hết, tôi giả sử rằng bạn biết rằng đó 6.2f * 10không chính xác là 62 do làm tròn điểm trôi nổi (thực ra đó là giá trị 61.99999809265137 khi được biểu thị bằng a double) và câu hỏi của bạn chỉ là tại sao hai phép tính dường như giống nhau dẫn đến giá trị sai.

Câu trả lời là trong trường hợp (int)(6.2f * 10), bạn đang lấy doublegiá trị 61.99999809265137 và cắt nó thành một số nguyên, mang lại 61.

Trong trường hợp float f = 6.2f * 10, bạn đang lấy giá trị kép 61.99999809265137 và làm tròn đến giá trị gần nhất float, là 62. Sau đó, bạn cắt nó floatthành một số nguyên và kết quả là 62.

Bài tập: Giải thích kết quả của chuỗi thao tác sau.

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

Cập nhật: Như đã đề cập trong các ý kiến, khái niệm 6.2f * 10là chính thức một floattừ tham số thứ hai có một chuyển đổi ngầm để floatđó là tốt hơn so với chuyển đổi ngầm để double.

Vấn đề thực tế là trình biên dịch được phép (nhưng không bắt buộc) sử dụng một trung gian có độ chính xác cao hơn loại chính thức (phần 11.2.2) . Đó là lý do tại sao bạn thấy các hành vi khác nhau trên các hệ thống khác nhau: Trong biểu thức (int)(6.2f * 10), trình biên dịch có tùy chọn giữ giá trị 6.2f * 10ở dạng trung gian có độ chính xác cao trước khi chuyển đổi sang int. Nếu có, thì kết quả là 61. Nếu không, thì kết quả là 62.

Trong ví dụ thứ hai, việc gán rõ ràng để floatbuộc làm tròn diễn ra trước khi chuyển đổi thành số nguyên.

Sự miêu tả

Số nổi một cách hiếm khi chính xác. 6.2flà một cái gì đó như 6.1999998.... Nếu bạn chuyển nó thành int, nó sẽ cắt nó và kết quả * 10 này là 61.

Kiểm tra DoubleConverterlớp Jon Skeets . Với lớp này, bạn thực sự có thể hình dung giá trị của một số trôi nổi dưới dạng chuỗi. Doublevà floatlà cả hai số trôi nổi , số thập phân thì không (nó là số điểm cố định).

Mẫu vật

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

Thêm thông tin

• Lớp DoubleConverter của Jon Skeet
• Assert.AreEqual () với System.Double trở nên thực sự khó hiểu
• Những gì mọi nhà khoa học máy tính nên biết về số học dấu phẩy động

Nhìn vào 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

Trình biên dịch làm giảm các biểu thức hằng số thời gian biên dịch thành giá trị không đổi của chúng và tôi nghĩ rằng nó làm cho một xấp xỉ sai ở một số điểm khi nó chuyển đổi hằng số thành int. Trong trường hợp speed2, chuyển đổi này được thực hiện không phải bởi trình biên dịch, mà bởi CLR và dường như chúng áp dụng các quy tắc khác nhau ...

Tôi đoán là 6.2fđại diện thực sự với độ chính xác nổi là 6.1999999trong khi 62fcó lẽ là một cái gì đó tương tự 62.00000001. (int)đúc luôn cắt ngắn giá trị thập phân để đó là lý do tại sao bạn có hành vi đó.

EDIT : Theo ý kiến ​​tôi đã đánh giá lại hành vi của intviệc chuyển sang một định nghĩa chính xác hơn nhiều.

Tôi đã biên dịch và phân tách mã này (trên Win7 / .NET 4.0). Tôi đoán rằng trình biên dịch đánh giá biểu thức hằng nổi là gấp đôi.

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 

Singlechỉ có 7 chữ số và khi truyền nó tới Int32trình biên dịch sẽ cắt tất cả các chữ số dấu phẩy động. Trong quá trình chuyển đổi, một hoặc nhiều chữ số có nghĩa có thể bị mất.

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

cho kết quả 619999980 vì vậy (Int32) (6.2f * 10) cho 61.

Nó khác nhau khi hai Đơn được nhân lên, trong trường hợp đó không có hoạt động cắt ngắn mà chỉ là xấp xỉ.

Xem http://msdn.microsoft.com/en-us/l Library / system.single.aspx

Có một lý do mà bạn đang nhập vào intthay vì phân tích cú pháp?

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

sau đó sẽ đọc

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

Sự khác biệt có lẽ là để làm tròn: nếu bạn chọn double bạn có thể sẽ nhận được một cái gì đó như 61.78426.

Xin lưu ý đầu ra sau đây

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

Đó là lý do tại sao bạn đang nhận được các giá trị khác nhau!