.NET中小数，浮点数和双精度之间的区别？

是什么区别decimal，float并double在.NET？

有人什么时候会使用其中之一？

float和double是浮点型二进制点类型。换句话说，它们代表这样的数字：

10001.10010110011

二进制数和二进制点的位置都编码在该值内。

decimal是浮点小数点类型。换句话说，它们代表这样的数字：

12345.65789

同样，小数点的数字和位置都被编码在该值之内，这decimal仍然是浮点类型而不是定点类型。

需要注意的重要一点是，人类习惯于以十进制形式表示非整数，并期望以十进制表示形式得到准确的结果。并非所有十进制数字都可以在二进制浮点数中精确表示（例如0.1），因此，如果您使用二进制浮点数，则实际上将近似为0.1。当使用浮点小数点时，您仍然会得到近似值-例如，不能精确表示1除以3的结果。

至于什么时候使用：

• 对于“自然精确的小数”值，最好使用decimal。这通常适用于人类发明的任何概念：财务价值是最明显的例子，但也有其他一些例子。例如，考虑给潜水员或溜冰者的分数。

• 如果读入的性质的更加伪影不能真正测量值准确反正float/ double更合适。例如，科学数据通常以这种形式表示。在这里，原始值一开始就不会是“十进制精度”，因此对于预期结果而言，保持“十进制精度”并不重要。浮点二进制点类型比十进制小得多。

精度是主要区别。

浮点数 -7位数字（32位）

双 -15-16位数字（64位）

十进制 -28-29有效数字（128位）

小数位数具有更高的精度，通常在要求高度准确性的金融应用程序中使用。小数要比double / float慢得多（在某些测试中，多达20倍）。

如果不进行强制转换，则不能比较小数和浮点数/双精度数，而可以进行浮点数和双精度数的比较。小数也允许编码或尾随零。

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                               |
+---------+----------------+---------+----------+---------------------------------------------+

有关更多信息，请参见此处。

我不会重复在其他答案和评论中已经回答过的大量好（和坏）信息，但是我将向您提示一些后续问题：

有人什么时候会使用其中之一？

使用十进制计数值

将浮点/双精度用作测量值

一些例子：

• 钱（我们数钱还是衡量钱？）

• 距离（我们计算距离还是测量距离？*）

• 分数（我们计算分数还是衡量分数？）

我们总是数钱，永远不要衡量。我们通常测量距离。我们经常计算分数。

*在某些情况下，我称之为标称距离，我们可能确实想“计算”距离。例如，也许我们正在处理显示到城市距离的国家标志，并且我们知道这些距离永远不会超过一个十进制数字（xxx.x km）。

float 7位精度

double 大约有15位数字的精度

decimal 约有28位精度

如果需要更高的精度，请使用double而不是float。在现代CPU中，两种数据类型几乎都具有相同的性能。使用float的唯一好处是它们占用的空间更少。实际上只有在您有很多的情况下才重要。

我发现这很有趣。每位计算机科学家都应了解的浮点运算法则

没有人提到

在默认设置下，浮点数（System.Single）和双精度数（System.Double）将永远不会使用溢出检查，而十进制（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。如果需要存储不是整数的数字，则需要另一种类型的变量。您可以使用double类型或float类型。您可以通过完全相同的方式设置这些类型的变量：您无需输入单词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位有效数字
• 两倍：±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电子表格中读取数值，将其转换为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

奇怪的是，解决方案是double先将Excel值转换为，然后转换为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会将它们设置为零。

奇。很奇怪。

对于诸如内存和性能都至关重要的游戏和嵌入式系统之类的应用程序，浮点数通常是首选的数字类型，因为它速度更快，是两倍大小的一半。整数曾经是首选武器，但浮点性能已超过现代处理器中的整数。十进制就正确了！

Decimal，Double和Float变量类型在存储值方面有所不同。精度是主要区别，其中float是单精度（32位）浮点数据类型，double是双精度（64位）浮点数据类型，而十进制是128位浮点数据类型。

浮点数-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对应于COBOL中的BINARY十进制！

遗憾的是，.Net中不存在用COBOL实现的其他数字类型。对于不了解COBOL的用户，COBOL中存在以下数字类型

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. Decimal，Double和Float变量类型在存储值方面有所不同。
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位有效数字）在金融应用程序中，最好使用十进制类型，因为它可以提供较高的准确性，并且易于避免舍入错误。对于需要精度的非整数数学，请使用十进制（例如货币和货币）

• 双 精度64位（15-16位数字）双精度类型可能是用于实值的最常用数据类型，除了处理资金外。对于不需要最精确答案的非整数数学，请使用double。

• 浮点 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