decimal， double在 c#中的区别

一句话总结

• double：二进制浮点（IEEE 754，64 位），速度快、范围大，但对十进制小数（比如货币）有不可避免的精度误差。适合科学计算、图形、向量、概率、机器学习、物理仿真等。
• decimal：十进制浮点（128 位，28–29 位有效十进制数），对十进制小数表示更精确，但范围小、速度慢。适合金融/会计、价格、税率、金额等。

 

 

 

核心差异速览

方面	double	decimal
位宽	64 位	128 位
表示	二进制浮点（base-2）	十进制浮点（base-10，96 位整数 + 0–28 的尺度因子）
有效数字	~15–17 位十进制有效数字	28–29 位十进制有效数字
数值范围	~ ±1.7E308	~ ±7.9E28
性能	更快（硬件指令支持更强）	更慢（软件实现为主）
典型用途	科学计算、几何、物理、图形	金融、价格、税务、货币累计
字面量后缀	默认浮点字面量是 double（如 0.1）	必须加 m/M 后缀（如 0.1m）
比较策略	浮点误差需容忍区间（epsilon）	一般能做精确相等（十进制场景）

注意：“更精确”仅指十进制小数（例如 0.1、0.01 这些十进制能有限表示的数）。在“科学计算精度”意义上，double 的相对误差控制更适合数值分析，但对金融小数累加不友好。

 

 

 

为什么会有误差？

• double 用 二进制 表示，像 0.1 在二进制是一个无限循环小数，只能近似存储 → 计算会出现微小误差。
• decimal 用 十进制 缩放存储，0.1 可以被精确表示，所以 0.1 + 0.2 在 decimal 下能得到准确的 0.3。

 

典型示例对比

1) 金额计算（推荐 decimal）

using System;class Program
{static void Main(){// double：二进制浮点误差double d1 = 0.1;double d2 = 0.2;double dSum = d1 + d2;Console.WriteLine($"double: 0.1 + 0.2 = {dSum:R}");   // 可能是 0.30000000000000004// decimal：十进制精确表示decimal m1 = 0.1m;decimal m2 = 0.2m;decimal mSum = m1 + m2;Console.WriteLine($"decimal: 0.1m + 0.2m = {mSum}");  // 0.3}
}

　　

输出（示例）：

double: 0.1 + 0.2 = 0.30000000000000004
decimal: 0.1m + 0.2m = 0.3

 

2) 比较策略（double 用容忍区间，decimal 直接等于）

 

// double 比较
double a = 1.0 - 0.9; // ~0.09999999999999998
double b = 0.1;
double eps = 1e-12; // 容忍区间
bool almostEqual = Math.Abs(a - b) < eps; // true// decimal 比较
decimal da = 1.0m - 0.9m; // 0.1m
decimal db = 0.1m;
bool equal = da == db; // true

　　

金融舍入（银行家舍入/四舍五入）

 

decimal price = 10.015m;
decimal roundedBanker = Math.Round(price, 2, MidpointRounding.ToEven);   // 银行家舍入
decimal roundedAway = Math.Round(price, 2, MidpointRounding.AwayFromZero); // 常规四舍五入
Console.WriteLine($"ToEven  : {roundedBanker}");
Console.WriteLine($"AwayFromZero: {roundedAway}");

　　

在金融系统中明确指定 MidpointRounding，并用 decimal 存储与结算。

 

4) 求和误差积累：double vs decimal

 

using System;
using System.Linq;class Program
{static void Main(){// 连加 0.01 一万次double d = 0.0;for (int i = 0; i < 10000; i++) d += 0.01;Console.WriteLine($"double sum of 0.01 x 10000 = {d:R}"); // 可能不是 100.0decimal m = 0.0m;for (int i = 0; i < 10000; i++) m += 0.01m;Console.WriteLine($"decimal sum of 0.01m x 10000 = {m}"); // 恰好 100.00}
}

　　

5) 性能与数学库

• double 运算通常更快；CPU 对 IEEE 754 binary64 有硬件加速。
• Math 类的大多数高级函数（Sin, Cos, Sqrt, Exp 等）以 double 为主，decimal 没有对应重载，需要先转 double：

 

decimal angleDeg = 30m;
double rad = (double)angleDeg * Math.PI / 180.0;
double s = Math.Sin(rad); // 使用 double

　

 

选择建议

• 金额/价格/税/汇率/计费/开票：decimal（避免二进制误差；对账和法务需要精确十进制）。
• 科学计算/统计/图形/物理/机器学习：double（范围更大、速度更快、生态更成熟）。
• 存储：数据库中金额字段用 DECIMAL(p, s)；应用层用 decimal，避免来回转换误差。
• 比较：
  • double：用 epsilon 容忍区间比较。
  • decimal：一般可直接相等比较（仍建议先按业务规则统一保留小数位与舍入）。

 

更多注意点与实践经验

1. 字面量后缀
   • 0.1 是 double；0.1m 才是 decimal。混用会有隐式转换/装箱风险，优先保持类型一致。
2. 格式化
   • 金额显示用格式串：amount.ToString("F2") 或 amount.ToString("C", culture).
3. 舍入策略统一
   • 统一用 Math.Round(value, scale, MidpointRounding.XXX)；不要依赖默认舍入（默认是 ToEven）。
4. 累加/折扣/税率
   • 全程 decimal，每步按统一精度舍入（例如保留 2 位），减少尾差。
5. 性能
   • decimal 运算一般比 double 慢几倍到十几倍；在高频数值计算路径上要谨慎。
6. 序列化/反序列化
   • JSON 中金额字段用字符串或高精度配置，避免语言间二进制浮点误差。
7. 泛型/第三方库
   • 许多数值算法库默认 double；若要用 decimal，可能需要自写实现或转换。

 

 

💡 为什么 double 用二进制表示时，像 0.1 会变成无限循环小数？

核心原因只有一个：

0.1 在二进制小数系统（base-2）中无法被有限位数精确表示，就像 1/3 在十进制里是无限循环的 0.333333… 一样。

我们来一步一步拆开。

---

1）为什么 0.1 在二进制是无限循环？

因为：

⭐ 十进制小数只有在分母可以被 10 的幂整除时，才能有限表示

例如：

• 1/2 = 0.5（有限）
• 1/4 = 0.25（有限）
• 1/5 = 0.2（有限）
• 1/3 = 0.3333…（无限循环）

因为：

0.1 = 1/10

要看它是否能用二进制有限表示，就要看 10 的分解能否完全被 2 的幂吸收。

而：

10 = 2 × 5

它含有一个 5，而 5 不是 2 的倍数，所以永远无法在 base-2 里被有限表示。

结论：1/10 在二进制中只能表示为无限循环小数。

---

2）数学推导：0.1 的二进制展开是无限循环

我们将 0.1 转为二进制，用乘 2 取整法：

（十进制 → 二进制小数常用算法）

0.1 * 2 = 0.2   → 整位 0
0.2 * 2 = 0.4   → 整位 0
0.4 * 2 = 0.8   → 整位 0
0.8 * 2 = 1.6   → 整位 1
0.6 * 2 = 1.2   → 整位 1
0.2 * 2 = 0.4   → 整位 0
...
然后无限循环

你会发现乘积的小数部分在：

0.2 → 0.4 → 0.8 → 0.6 → 0.2 → ...

开始循环了！

所以 0.1 的二进制表示是无限循环小数：

0.0001100110011001100110011001100110011...(无限循环)

double 只有 53 bit 精度， 只能截断成有限位近似值。

---

3）因此 double 存储 0.1 的内部真实值 ≠ 0.1

IEEE 754 的 double 格式：

类型	位数
符号位	1
指数位	11
尾数位（有效位）	52（实际是 53 bit 精度）

但 0.1 的二进制无限小数，只能 截断到有限的 53 位，导致只存了一个近似值。

.NET 实际存的是（十六进制表示）：

3FB999999999999A （IEEE 754）

换算回十进制：

0.1000000000000000055511151231257827021181583404541015625

所以 double 永远不可能存成真正的 0.1。

---

4）这导致典型问题：0.1 + 0.2 != 0.3

因为：

0.1 真实存储值 = 略大于 0.1  
0.2 真实存储值 = 略大于 0.2
两者相加的结果也不是精确 0.3

示例：

 

Console.WriteLine(0.1 + 0.2 == 0.3); // false

Console.WriteLine(0.1 + 0.2); // 0.30000000000000004

 

原因就是二进制浮点的近似误差。

 

 

 

5）对比：decimal 为什么能准确表示？

因为：

decimal 是十进制浮点（base-10），内部用整数 × 10 的幂来存储，例如 0.1 存成 1 / 10。

也就是说：

0.1m  →  整数 1，scale = 1（表示小数点位置）

decimal 是完全为金融领域的十进制构造的，因此可以精确存储 0.1。

---

6）易懂类比

进制	能否表示 0.1？	类比
十进制	✓ 可以	0.1 是 1/10，10 是十进制基数
二进制	✗ 不可以	就像 1/3 在十进制里无限循环一样

0.1 对二进制来说，就像 1/3 对十进制一样，是永远写不完的小数。

---

7）最终总结（非常重要）

✔ 双精度浮点数（double）的问题

• double 使用 二进制浮点（base-2）
• 0.1 = 1/10
• 10 含有素因子 5，不能由 2 的幂整除
• 所以 0.1 在二进制是无限循环
• double 只能 截断存储为近似值
• 所以会出现 0.1 + 0.2 ≠ 0.3

✔ decimal 的优势

• decimal 使用 十进制浮点（base-10）
• 1/10 可以被 10 的幂表示
• 因此可以 精确存储 0.1
• 是金融计算的正确选择