ความแตกต่างระหว่างทศนิยมทศนิยมและสองเท่าใน. NET?

อะไรคือความแตกต่างระหว่างdecimal, floatและdoubleใน .NET?

เมื่อไหร่จะมีคนใช้อย่างใดอย่างหนึ่งเหล่านี้?

floatและdoubleจะลอยไบนารีประเภทจุด กล่าวอีกนัยหนึ่งมันเป็นตัวแทนของตัวเลขเช่นนี้:

10001.10010110011

หมายเลขไบนารี่และตำแหน่งของจุดไบนารี่ถูกเข้ารหัสทั้งคู่ภายในค่า

decimalเป็นลอยทศนิยมชนิดจุด กล่าวอีกนัยหนึ่งมันเป็นตัวแทนของตัวเลขเช่นนี้:

12345.65789

อีกครั้งหมายเลขและที่ตั้งของจุดทศนิยมจะถูกเข้ารหัสภายในค่านั่นคือสิ่งที่ทำให้decimalยังคงเป็นประเภทจุดลอยแทนประเภทจุดคงที่

สิ่งสำคัญที่ควรทราบคือมนุษย์จะใช้เพื่อเป็นตัวแทนที่ไม่ใช่จำนวนเต็มในรูปแบบทศนิยมและคาดหวังผลลัพธ์ที่แน่นอนในการเป็นตัวแทนทศนิยม; ไม่ใช่ทศนิยมทั้งหมดที่สามารถแทนได้ในทศนิยมทศนิยมเช่น - 0.1 ดังนั้นถ้าคุณใช้ค่าทศนิยมลอยตัวไบนารีคุณจะได้ค่าประมาณ 0.1 คุณจะยังคงได้รับการประมาณเมื่อใช้ทศนิยมทศนิยมเช่นกัน - ผลลัพธ์ของการหาร 1 ด้วย 3 ไม่สามารถแสดงได้อย่างแน่นอน

เป็นสิ่งที่จะใช้เมื่อ:

• สำหรับค่าซึ่งเป็น "ธรรมชาติที่แน่นอนทศนิยม" decimalมันเป็นเรื่องดีที่จะใช้ สิ่งนี้มักจะเหมาะสำหรับแนวคิดใด ๆ ที่มนุษย์คิดค้นขึ้นมา: คุณค่าทางการเงินเป็นตัวอย่างที่ชัดเจนที่สุด พิจารณาคะแนนที่ให้กับนักดำน้ำหรือนักสเก็ตน้ำแข็ง

• สำหรับค่าซึ่งเป็นสิ่งประดิษฐ์อื่น ๆ จากธรรมชาติที่ไม่สามารถวัดได้จริงๆว่าแล้วfloat/ doubleมีความเหมาะสมมากขึ้น ตัวอย่างเช่นข้อมูลทางวิทยาศาสตร์มักจะแสดงในรูปแบบนี้ ที่นี่ค่าดั้งเดิมจะไม่ "ถูกต้องทางทศนิยม" ในการเริ่มต้นดังนั้นจึงไม่สำคัญสำหรับผลลัพธ์ที่คาดหวังในการรักษา "ความแม่นยำทศนิยม" ชนิดจุดลอยตัวแบบไบนารีนั้นทำงานได้เร็วกว่าทศนิยม

ความแม่นยำเป็นความแตกต่างหลัก

Float - 7 หลัก (32 บิต)

ดับเบิล -15-16 หลัก (64 บิต)

ทศนิยมที่สำคัญ -28-29 หลัก (128 บิต)

ทศนิยมมีความแม่นยำสูงกว่ามากและมักใช้ในแอปพลิเคชันทางการเงินที่ต้องการความแม่นยำระดับสูง ทศนิยมนั้นช้ากว่ามาก (มากถึง 20 เท่าในการทดสอบบางอย่าง) กว่าแบบ double / float

Decimals and Floats / Doubles ไม่สามารถเปรียบเทียบได้โดยไม่ต้องใช้ cast ในขณะที่ Float และ Doubles สามารถทำได้ ทศนิยมยังอนุญาตให้มีการเข้ารหัสหรือต่อท้ายเลขศูนย์

float flt = 1F/3;
double dbl = 1D/3;
decimal dcm = 1M/3;
Console.WriteLine("float: {0} double: {1} decimal: {2}", flt, dbl, dcm);

ผลลัพธ์ :

float: 0.3333333  
double: 0.333333333333333  
decimal: 0.3333333333333333333333333333

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

• การสูญเสียความแม่นยำเป็นที่ยอมรับในการคำนวณทางวิทยาศาสตร์มากมายเนื่องจากข้อ จำกัด ในทางปฏิบัติของปัญหาทางกายภาพหรือสิ่งประดิษฐ์ที่วัด การสูญเสียความแม่นยำไม่เป็นที่ยอมรับในด้านการเงิน
• ทศนิยมจะมาก (มาก) ช้ากว่าการลอยและสองเท่าสำหรับการดำเนินการส่วนใหญ่เนื่องจากการดำเนินการจุดลอยตัวจะทำในไบนารีในขณะที่สิ่งทศนิยมจะทำในฐาน 10 (เช่นลอยและคู่ถูกจัดการโดยฮาร์ดแวร์ FPU เช่น MMX / SSE ในขณะที่ทศนิยมถูกคำนวณในซอฟต์แวร์)
• ทศนิยมมีช่วงค่าที่น้อยกว่าที่ยอมรับไม่ได้ถึงสองเท่าแม้ว่าจะสนับสนุนตัวเลขที่มีความแม่นยำมากขึ้นก็ตาม ดังนั้นทศนิยมไม่สามารถใช้แทนค่าทางวิทยาศาสตร์จำนวนมากได้

+---------+----------------+---------+----------+---------------------------------------------+
| C#      | .Net Framework | Signed? | Bytes    | Possible Values                             |
| Type    | (System) type  |         | Occupied |                                             |
+---------+----------------+---------+----------+---------------------------------------------+
| sbyte   | System.Sbyte   | Yes     | 1        | -128 to 127                                 |
| short   | System.Int16   | Yes     | 2        | -32768 to 32767                             |
| int     | System.Int32   | Yes     | 4        | -2147483648 to 2147483647                   |
| long    | System.Int64   | Yes     | 8        | -9223372036854775808 to 9223372036854775807 |
| byte    | System.Byte    | No      | 1        | 0 to 255                                    |
| ushort  | System.Uint16  | No      | 2        | 0 to 65535                                  |
| uint    | System.UInt32  | No      | 4        | 0 to 4294967295                             |
| ulong   | System.Uint64  | No      | 8        | 0 to 18446744073709551615                   |
| float   | System.Single  | Yes     | 4        | Approximately ±1.5 x 10-45 to ±3.4 x 1038   |
|         |                |         |          |  with 7 significant figures                 |
| double  | System.Double  | Yes     | 8        | Approximately ±5.0 x 10-324 to ±1.7 x 10308 |
|         |                |         |          |  with 15 or 16 significant figures          |
| decimal | System.Decimal | Yes     | 12       | Approximately ±1.0 x 10-28 to ±7.9 x 1028   |
|         |                |         |          |  with 28 or 29 significant figures          |
| char    | System.Char    | N/A     | 2        | Any Unicode character (16 bit)              |
| bool    | System.Boolean | N/A     | 1 / 2    | true or false                               |
+---------+----------------+---------+----------+---------------------------------------------+

ดูที่นี่สำหรับข้อมูลเพิ่มเติม

ฉันจะไม่ย้ำข้อมูลที่ดี (และไม่ดีบางส่วน) ตอบแล้วในคำตอบและความคิดเห็นอื่น ๆ แต่ฉันจะตอบคำถามติดตามของคุณด้วยเคล็ดลับ:

เมื่อไหร่จะมีคนใช้อย่างใดอย่างหนึ่งเหล่านี้?

ใช้ทศนิยมสำหรับค่าที่นับ

ใช้ float / double สำหรับค่าที่วัดได้

ตัวอย่างบางส่วน:

• เงิน (เราจะนับเงินหรือวัดเงิน)

• ระยะทาง (เรานับระยะทางหรือวัดระยะทางหรือไม่ *)

• คะแนน (เราจะนับคะแนนหรือวัดคะแนนหรือไม่)

เรานับเงินอยู่เสมอและไม่ควรวัด เรามักจะวัดระยะทาง เรามักจะนับคะแนน

* ในบางกรณีสิ่งที่ฉันจะเรียกระยะทางที่ระบุเราอาจต้องการระยะทาง 'นับ' ตัวอย่างเช่นบางทีเรากำลังติดต่อกับสัญลักษณ์ของประเทศที่แสดงระยะทางไปยังเมืองต่างๆและเรารู้ว่าระยะทางเหล่านั้นไม่เคยมีทศนิยมมากกว่าหนึ่งหลัก (xxx.x km)

float ความแม่นยำ 7 หลัก

double มีความแม่นยำประมาณ 15 หลัก

decimal มีความแม่นยำประมาณ 28 หลัก

หากคุณต้องการความแม่นยำที่ดีกว่าให้ใช้ double แทน float ในซีพียูสมัยใหม่ทั้งสองประเภทข้อมูลมีประสิทธิภาพเกือบเหมือนกัน ประโยชน์เพียงอย่างเดียวของการใช้โฟลตคือพวกเขาใช้พื้นที่น้อยลง มีความสำคัญในทางปฏิบัติหากคุณมีหลายสิ่งเท่านั้น

ฉันพบว่าสิ่งนี้น่าสนใจ สิ่งที่นักวิทยาศาสตร์คอมพิวเตอร์ทุกคนควรรู้เกี่ยวกับเลขคณิตทศนิยม

ไม่มีใครพูดถึงเรื่องนี้

ในการตั้งค่าเริ่มต้น Floats (System.Single) และ doubles (System.Double) จะไม่ใช้การตรวจสอบโอเวอร์โฟลว์ในขณะที่ Decimal (System.Decimal) จะใช้การตรวจสอบโอเวอร์โฟลว์เสมอ

ฉันหมายถึง

decimal myNumber = decimal.MaxValue;
myNumber += 1;

พ่นOverflowException

แต่สิ่งเหล่านี้ไม่ได้:

float myNumber = float.MaxValue;
myNumber += 1;

&

double myNumber = double.MaxValue;
myNumber += 1;

1. Double และ float สามารถถูกหารด้วยเลขจำนวนเต็มโดยไม่มีข้อยกเว้นทั้งในการคอมไพล์และรันไทม์
2. ทศนิยมไม่สามารถหารด้วยเลขจำนวนเต็ม การรวบรวมจะล้มเหลวเสมอหากคุณทำเช่นนั้น

จำนวนเต็มตามที่กล่าวถึงคือจำนวนเต็ม พวกเขาไม่สามารถเก็บคะแนนบางอย่างเช่น. 7, .42 และ .007 หากคุณต้องการเก็บตัวเลขที่ไม่ใช่ตัวเลขทั้งหมดคุณต้องการตัวแปรชนิดอื่น คุณสามารถใช้ประเภทคู่หรือประเภทลอย คุณตั้งค่าเหล่านี้ประเภทของตัวแปรขึ้นมาในทางเดียวกันว่า: แทนการใช้คำว่าintคุณพิมพ์หรือdouble floatแบบนี้:

float myFloat;
double myDouble;

( floatสั้นสำหรับ "ทศนิยม" และหมายถึงตัวเลขที่มีบางสิ่งบางอย่างในจุดสิ้นสุด)

ความแตกต่างระหว่างสองคือขนาดของตัวเลขที่พวกเขาสามารถถือ สำหรับfloatคุณสามารถมีตัวเลขได้สูงสุด 7 หลัก สำหรับdoubles คุณสามารถมีได้สูงสุด 16 หลัก เพื่อให้แม่นยำยิ่งขึ้นนี่คือขนาดทางการ:

float:  1.5 × 10^-45  to 3.4 × 10^38  
double: 5.0 × 10^-324 to 1.7 × 10^308

floatเป็นหมายเลข 32 บิตและdoubleเป็นหมายเลข 64 บิต

ดับเบิลคลิกที่ปุ่มใหม่ของคุณเพื่อรับรหัส เพิ่มสามบรรทัดต่อไปนี้ในรหัสปุ่มของคุณ:

double myDouble;
myDouble = 0.007;
MessageBox.Show(myDouble.ToString());

หยุดโปรแกรมของคุณและกลับไปที่หน้าต่างการเข้ารหัส เปลี่ยนบรรทัดนี้:

myDouble = 0.007;
myDouble = 12345678.1234567;

เรียกใช้โปรแกรมของคุณแล้วคลิกปุ่มสองครั้งของคุณ กล่องข้อความแสดงตัวเลขอย่างถูกต้อง เพิ่มหมายเลขอื่นในท้ายที่สุดแล้วและ C # จะปัดขึ้นหรือลงอีกครั้ง คุณธรรมคือถ้าคุณต้องการความแม่นยำระวังการปัดเศษ!

• ลอย: ± 1.5 x 10 ^ -45 ถึง± 3.4 x 10 ^ 38 (~ 7 ตัวเลขที่สำคัญ
• double: ± 5.0 x 10 ^ -324 ถึง± 1.7 x 10 ^ 308 (ตัวเลขสำคัญ 15-16 รายการ)
• ทศนิยม: ± 1.0 x 10 ^ -28 ถึง± 7.9 x 10 ^ 28 (ตัวเลขสำคัญ 28-29)

นี่เป็นหัวข้อที่น่าสนใจสำหรับฉันในวันนี้เราเพิ่งมีข้อผิดพลาดเล็กน้อยที่น่ารังเกียจเกี่ยวกับdecimalการมีความแม่นยำน้อยกว่าfloatการมีความแม่นยำน้อยกว่า

ในรหัส C # ของเราเรากำลังอ่านค่าตัวเลขจากสเปรดชีท Excel แปลงเป็น a decimalแล้วส่งdecimalกลับไปยังบริการเพื่อบันทึกลงในฐานข้อมูลSQL Server

Microsoft.Office.Interop.Excel.Range cell = …
object cellValue = cell.Value2;
if (cellValue != null)
{
    decimal value = 0;
    Decimal.TryParse(cellValue.ToString(), out value);
}

ทีนี้สำหรับค่า Excel ของเราเกือบทั้งหมดแล้วมันก็ใช้ได้ดี แต่สำหรับบางค่า Excel ที่มีขนาดเล็กมากการใช้ค่านั้นdecimal.TryParseหายไปโดยสิ้นเชิง ตัวอย่างหนึ่งคือ

• cellValue = 0.00006317592

• Decimal.TryParse (cellValue.ToString (), ค่าออก); // จะคืนค่า0

วิธีแก้ปัญหาที่แปลกประหลาดคือการแปลงค่าของ Excel ให้เป็นdoubleอันดับแรกจากนั้นให้เป็นdecimal:

Microsoft.Office.Interop.Excel.Range cell = …
object cellValue = cell.Value2;
if (cellValue != null)
{
    double valueDouble = 0;
    double.TryParse(cellValue.ToString(), out valueDouble);
    decimal value = (decimal) valueDouble;
    …
}

แม้ว่าจะdoubleมีความแม่นยำน้อยกว่า a decimalจริง ๆ แล้วมั่นใจว่าตัวเลขขนาดเล็กจะยังคงรับรู้ ด้วยเหตุผลบางอย่างdouble.TryParseจริง ๆ แล้วสามารถดึงข้อมูลจำนวนน้อยเช่นนั้นในขณะที่decimal.TryParseจะตั้งค่าเป็นศูนย์

แปลก แปลกมาก.

สำหรับแอปพลิเคชั่นเช่นเกมและระบบฝังตัวที่หน่วยความจำและประสิทธิภาพมีความสำคัญอย่างมากโฟลตมักเป็นตัวเลือกประเภทตัวเลขเนื่องจากมันเร็วกว่าและมีขนาดเท่าตัวครึ่งหนึ่ง จำนวนเต็มเคยเป็นอาวุธของตัวเลือก แต่ประสิทธิภาพของจุดลอยมีจำนวนเต็มในโปรเซสเซอร์ที่ทันสมัย ทศนิยมไม่ถูกต้อง!

ชนิดตัวแปรทศนิยมทศนิยมและลอยแตกต่างกันในวิธีการจัดเก็บค่า ความแม่นยำคือความแตกต่างหลักที่ลอยเป็นชนิดข้อมูลจุดลอยตัวความแม่นยำเดียว (32 บิต) double คือชนิดข้อมูลจุดลอยตัวที่มีความแม่นยำสองเท่า (64 บิต) และทศนิยมเป็นชนิดข้อมูลจุดลอยตัว 128 บิต

Float - 32 บิต (7 หลัก)

สอง - 64 บิต (15-16 หลัก)

ทศนิยม - 128 บิต (28-29 หลักสำคัญ)

เพิ่มเติมเกี่ยวกับ ... ความแตกต่างระหว่างทศนิยมลอยและดับเบิล

ปัญหาเกี่ยวกับประเภทเหล่านี้ทั้งหมดคือว่ามีบางอย่างไม่แน่ชัดว่ามีอยู่หรือไม่และปัญหานี้อาจเกิดขึ้นกับตัวเลขทศนิยมขนาดเล็กเช่นในตัวอย่างต่อไปนี้

Dim fMean as Double = 1.18
Dim fDelta as Double = 0.08
Dim fLimit as Double = 1.1

If fMean - fDelta < fLimit Then
    bLower = True
Else
    bLower = False
End If

คำถาม: ตัวแปร bLower ประกอบด้วยค่าใด?

คำตอบ: บนเครื่อง 32 บิต bLower ประกอบด้วย TRUE !!!

ถ้าฉันแทนที่ Double ด้วย Decimal, bLower มี FALSE ซึ่งเป็นคำตอบที่ดี

สองเท่าปัญหาคือ fMean-fDelta = 1.09999999999 ที่ต่ำกว่า 1.1

ข้อควรระวัง: ฉันคิดว่าปัญหาเดียวกันนี้สามารถเกิดขึ้นได้กับตัวเลขอื่นเนื่องจากทศนิยมเป็นเพียงสองเท่าที่มีความแม่นยำสูงกว่าและความแม่นยำก็มีขีด จำกัด อยู่เสมอ

ในความเป็นจริง Double, Float และ Decimal สอดคล้องกับทศนิยม BINARY ใน COBOL!

เป็นเรื่องน่าเศร้าที่ประเภทตัวเลขอื่น ๆ ที่ใช้ใน COBOL ไม่มีอยู่ใน. Net สำหรับผู้ที่ไม่ทราบภาษาโคบอลมีอยู่ในภาษาโคบอลประเภทต่อไปนี้เป็นตัวเลข

BINARY or COMP like float or double or decimal
PACKED-DECIMAL or COMP-3 (2 digit in 1 byte)
ZONED-DECIMAL (1 digit in 1 byte) 

ในคำง่าย ๆ :

1. ชนิดตัวแปรทศนิยมทศนิยมและลอยแตกต่างกันในวิธีการจัดเก็บค่า
2. ความแม่นยำคือความแตกต่างหลัก (โปรดสังเกตว่านี่ไม่ใช่ความแตกต่างเดียว) โดยที่floatเป็นชนิดข้อมูลจุดลอยตัวที่มีความแม่นยำเดียว (32 บิต) doubleคือความแม่นยำสองเท่า (64 บิต) ชนิดข้อมูลทศนิยมและทศนิยมเป็น 128 บิต ชนิดข้อมูลจุดลอย
3. ตารางสรุป:

/==========================================================================================
    Type       Bits    Have up to                   Approximate Range 
/==========================================================================================
    float      32      7 digits                     -3.4 × 10 ^ (38)   to +3.4 × 10 ^ (38)
    double     64      15-16 digits                 ±5.0 × 10 ^ (-324) to ±1.7 × 10 ^ (308)
    decimal    128     28-29 significant digits     ±7.9 x 10 ^ (28) or (1 to 10 ^ (28)
/==========================================================================================

ความแตกต่างที่สำคัญระหว่างกันคือความแม่นยำ

floatคือ32-bitตัวเลขdoubleคือ64-bitตัวเลขและdecimalเป็น128-bitตัวเลข

• ทศนิยม 128 บิต (28-29 หลักสำคัญ) ในกรณีของการใช้งานทางการเงินควรใช้ประเภททศนิยมเพราะให้ความแม่นยำระดับสูงและง่ายต่อการหลีกเลี่ยงข้อผิดพลาดในการปัดเศษใช้ทศนิยมสำหรับคณิตศาสตร์ที่ไม่ใช่จำนวนเต็มที่ต้องการความแม่นยำ (เช่น เงินและสกุลเงิน)

• Double 64 bit (15-16 หลัก) Double Type เป็นประเภทข้อมูลที่ใช้งานมากที่สุดสำหรับค่าจริงยกเว้นการจัดการเงิน ใช้สองเท่าสำหรับคณิตศาสตร์ที่ไม่ใช่จำนวนเต็มซึ่งไม่จำเป็นต้องใช้คำตอบที่แม่นยำที่สุด

• Float 32 บิต (7 หลัก) ส่วนใหญ่จะใช้ในไลบรารีกราฟิกเพราะความต้องการพลังการประมวลผลสูงมากรวมทั้งใช้สถานการณ์ที่สามารถทนต่อข้อผิดพลาดในการปัดเศษ

Decimalsช้ากว่าdouble/floatมาก

DecimalsและFloats/Doublesไม่สามารถเปรียบเทียบได้โดยไม่ต้องใช้นักแสดงในขณะที่FloatsและDoublesสามารถ

Decimals อนุญาตการเข้ารหัสหรือต่อท้ายเลขศูนย์

เพื่อกำหนดทศนิยมทศนิยมและคู่ใน. Net (c #)

คุณต้องพูดถึงค่าเป็น:

Decimal dec = 12M/6;
Double dbl = 11D/6;
float fl = 15F/6;

และตรวจสอบผลลัพธ์

และไบต์ที่ถูกครอบครองโดยแต่ละคนนั้น

Float - 4
Double - 8
Decimal - 12