ZetCode

C# 浮点类型

最后修改日期：2025 年 4 月 1 日

C# 提供了三种浮点类型：float、double 和 decimal，每种类型都具有不同的精度和用例。 本教程涵盖它们的特性、正确用法和常见陷阱。

C# 中的浮点类型提供了处理实数的能力，特别是那些需要小数精度的实数。.NET Framework 提供了两种主要的浮点数据类型：float 和 double。 此外，decimal 类型可用于需要更高精度的场景，例如财务计算。 每种类型都具有独特的特性，使其适合特定的用例。

float 类型，也称为单精度浮点数，占用 4 字节内存，精度约为 7 个有效数字。 它非常适合内存优化至关重要的应用程序，例如 3D 图形渲染、科学模拟或游戏开发。 但是，float 类型的较低精度可能会导致舍入误差，使其不太适合需要精确计算的应用程序。

double 类型，或双精度浮点数，由于其更高的精度和更广泛的适用性，在 C# 中更常用。 它占用 8 字节内存，并提供大约 15-16 个有效数字的精度。 这使得 double 非常适合通用应用程序，包括工程模拟、机器学习算法和需要高度准确性的计算。 尽管与 float 相比精度有所提高，但 double 仍然容易受到浮点运算固有的舍入误差的影响。

decimal 类型的独特之处在于它是专门为需要精确数值表示的应用程序而设计的，例如财务计算和货币运算。 它占用 16 字节的内存，并提供高达 28-29 个有效数字的精度。 与 float 和 double 不同，decimal 使用以 10 为基数的表示，这消除了处理诸如 0.1 或 0.2 等分数时常见的舍入误差。 虽然它提供了卓越的精度和准确性，但权衡是更高的内存使用率和比 float 和 double 更慢的性能。

C# 中的浮点类型具有其表示形式固有的局限性。 有限的精度可能会导致不准确，尤其是在涉及减法或除法的算术运算期间。 此外，由于硬件实现方式的差异，浮点数的表示在不同平台之间可能会略有不同。 对于关键应用程序（例如密码学或金融系统），必须仔细管理这些限制，通常需要使用 decimal 而不是其他浮点类型。

C# 浮点类型概述

本节介绍 C# 中的三种浮点类型及其基本属性。 了解这些类型对于为您的应用程序选择合适的类型至关重要。 每种类型的大小、精度和范围都不同，从而影响性能和准确性。 下面的示例演示了它们的声明并输出它们的值和范围。 这种基础知识有助于避免常见的编程错误。

FloatingPointTypes.cs
// Floating-point declarations
float singlePrecision = 1.23456789f;  // 32-bit
double doublePrecision = 1.2345678901234567; // 64-bit
decimal highPrecision = 1.2345678901234567890123456789m; // 128-bit

Console.WriteLine($"float: {singlePrecision}");
Console.WriteLine($"double: {doublePrecision}");
Console.WriteLine($"decimal: {highPrecision}");

// Type information
Console.WriteLine($"\nfloat range: {float.MinValue} to {float.MaxValue}");
Console.WriteLine($"double range: {double.MinValue} to {double.MaxValue}");
Console.WriteLine($"decimal range: {decimal.MinValue} to {decimal.MaxValue}");

Console.WriteLine($"\nfloat size: {sizeof(float)} bytes");
Console.WriteLine($"double size: {sizeof(double)} bytes");
Console.WriteLine($"decimal size: {sizeof(decimal)} bytes");

// Additional example: Scientific notation
float sciFloat = 1.23e-10f;
double sciDouble = 4.56e20;
Console.WriteLine($"\nScientific float: {sciFloat}");
Console.WriteLine($"Scientific double: {sciDouble}");

float 类型，也称为 System.Single，是符合 IEEE 754 标准的 32 位单精度数字。 它提供大约 6-9 个有效十进制数字，范围从 ±1.5×10⁻⁴⁵ 到 ±3.4×10³⁸，使其适合精度需求有限的应用程序。 您必须在 float 字面量后附加“f”或“F”后缀才能将它们与 double 区分开来。 相比之下，double (System.Double) 是 64 位双精度类型，具有 15-17 个有效数字和更广泛的范围，从 ±5.0×10⁻³²⁴ 到 ±1.7×10³⁰⁸。 作为 C# 的默认浮点类型，它可以有效地平衡精度和性能。

decimal 类型 (System.Decimal) 是一种 128 位高精度类型，提供 28-29 个有效数字，范围为 ±1.0×10⁻²⁸ 到 ±7.9×10²⁸，使用“m”或“M”后缀。 与 float 和 double 不同，它不遵循 IEEE 754，而是使用以 10 为基数的表示，非常适合财务计算。 这种类型在需要精确十进制精度的地方表现出色，尽管它会消耗更多内存。 每种类型的大小（float 为 4 字节，double 为 8 字节，decimal 为 16 字节）会影响内存使用。 选择正确的类型取决于您的应用程序的精度和性能要求。

精度与舍入

使用 C# 中的浮点类型时，精度和舍入至关重要。 基于二进制的类型（如 float 和 double）通常难以处理十进制分数，从而导致意外的结果。 本节通过示例探讨了这些问题，并展示了 decimal 的不同之处。 还演示了正确的舍入技术，以有效地管理精度。 了解这些概念可以防止计算中出现细微的错误。

PrecisionExamples.cs
// Classic floating-point precision issue
double a = 0.1;
double b = 0.2;
double sum = a + b;

Console.WriteLine($"0.1 + 0.2 = {sum}");
Console.WriteLine($"0.1 + 0.2 == 0.3? {sum == 0.3}");
Console.WriteLine($"Actual sum: {sum.ToString("G17")}");

// Decimal precision example
decimal d1 = 0.1m;
decimal d2 = 0.2m;
decimal dSum = d1 + d2;

Console.WriteLine($"\ndecimal 0.1 + 0.2 = {dSum}");
Console.WriteLine($"decimal 0.1 + 0.2 == 0.3m? {dSum == 0.3m}");

// Rounding modes
double value = 2.34567;
Console.WriteLine($"\nRounding examples:");
Console.WriteLine($"Math.Round({value}, 2): {Math.Round(value, 2)}");
Console.WriteLine($"Math.Floor({value}): {Math.Floor(value)}");
Console.WriteLine($"Math.Ceiling({value}): {Math.Ceiling(value)}");

// Additional rounding example
double pi = 3.14159;
Console.WriteLine($"\nPi rounded to 3 digits: {Math.Round(pi, 3)}");

Float 和 double 是二进制浮点类型，由于其以 2 为底数的性质，无法精确表示许多十进制分数，例如 0.1 或 0.2。 这会导致小错误，如当 0.1 + 0.2 不完全等于 0.3 时所见，而是使用 ToString("G17") 以完整精度查看时显示为 0.30000000000000004。 但是，decimal 类型使用以 10 为基数的系统，确保精确表示这些分数，使 0.1m + 0.2m 精确地等于 0.3m，但代价是更高的内存使用率。

float 和 double 中的舍入误差可能会在重复计算中累积，因此像 Math.Round、Math.Floor 和 Math.Ceiling 这样的方法对于控制至关重要。 例如，Math.Round(2.34567, 2) 产生 2.35，而 Math.Floor 和 Math.Ceiling 提供整数边界，有助于有效地管理精度。

比较浮点值

由于 C# 中精度有限，比较浮点值需要小心。 由于累积的错误，直接相等性检查通常会失败，因此需要其他方法。 本节提供了一个强大的比较方法，并处理特殊值，如 NaN 和 Infinity。 示例代码清楚地说明了这些挑战和解决方案。 掌握这些技术可确保程序中可靠的比较。

FloatingComparison.cs
bool NearlyEqual(double a, double b, double epsilon = 1e-10)
{
    double absA = Math.Abs(a);
    double absB = Math.Abs(b);
    double diff = Math.Abs(a - b);
    
    if (a == b) return true;

    if (a == 0 || b == 0 || diff < double.Epsilon) 
    {
        return diff < (epsilon * double.Epsilon);
    }
    
    return diff / (absA + absB) < epsilon;
}


double x = 0.1 + 0.2;
double y = 0.3;

Console.WriteLine($"Direct equality: {x == y}");
Console.WriteLine($"NearlyEqual: {NearlyEqual(x, y)}");
Console.WriteLine($"Difference: {x - y}");

// Special values
double nan = double.NaN;
double inf = double.PositiveInfinity;

Console.WriteLine($"\nNaN == NaN: {nan == nan}");
Console.WriteLine($"double.IsNaN(nan): {double.IsNaN(nan)}");
Console.WriteLine($"inf == inf: {inf == inf}");

// Additional example
double small = 1e-15;
double zero = 0.0;
Console.WriteLine($"\nNearlyEqual({small}, {zero}): {NearlyEqual(small, zero)}");

由于精度误差，与 float 或 double 的直接相等性比较 (==) 不可靠，因为 0.1 + 0.2 不完全匹配 0.3。 相反，像 NearlyEqual 方法这样的相对 epsilon 比较检查差异是否相对于数字的大小来说很小，通常使用像 1e-10 这样的小 epsilon。 对于接近零的值，针对极小阈值（例如，double.Epsilon）进行绝对比较会更好，从而确保边缘情况下的准确性。

像 NaN（非数字）和 Infinity 这样的特殊值需要像 double.IsNaN 或 double.IsInfinity 这样的方法，因为按照定义 NaN != NaN，而 Infinity == Infinity 成立。 当精确十进制精度至关重要时，使用 decimal 可以完全避免这些问题，尽管它速度较慢且内存密集。

用于财务计算的 Decimal 类型

decimal 类型在精度不可协商的财务应用程序中表现出色。 本节将其准确性与浮点近似值进行了对比，并展示了舍入技术。 示例说明了复利和货币舍入，突出了 decimal 的优势。 选择 decimal 可确保计算符合实际预期，例如银行对账单。 它是 C# 编程中货币准确性的重要工具。

DecimalExamples.cs
// Financial calculations with decimal
decimal principal = 1000.00m;
decimal interestRate = 0.05m; // 5%
int years = 10;

decimal futureValue = principal * (decimal)Math.Pow(1 + (double)interestRate, years);
Console.WriteLine($"Future value (floating-point): {futureValue:C}");

// Accurate decimal calculation
futureValue = principal;
for (int i = 0; i < years; i++) {
    futureValue *= (1 + interestRate);
}
Console.WriteLine($"Accurate future value: {futureValue:C}");

// Rounding financial values
decimal payment = 123.456789m;
Console.WriteLine($"\nPayment rounded to cents: {decimal.Round(payment, 2)}");
Console.WriteLine($"Payment rounded up: {decimal.Ceiling(payment)}");
Console.WriteLine($"Payment rounded down: {decimal.Floor(payment)}");

// Additional example: Tax calculation
decimal price = 19.99m;
decimal taxRate = 0.08m;
decimal tax = decimal.Round(price * taxRate, 2);
Console.WriteLine($"\nTax on {price:C}: {tax:C}");

Decimal 非常适合需要精确十进制表示的财务计算，例如贷款利息或货币总额，避免了 float/double 舍入误差。 它非常适合货币值，即使在会计系统或法律合规性中，像 0.01 这样微小的差异也是不可接受的。 它一致的舍入行为，使用像 decimal.Round() 这样的方法，确保了可预测的结果，这对于财务报告至关重要。

Decimal 还在其范围内精确处理非常大或非常小的数字，不像 float/double 会在极端情况下失去准确性。 当精度超过性能时使用它，例如计算 19.99 美元的价格，加上 8% 的税，正好是 1.60 美元。

最佳实践

选择正确的浮点类型并正确处理它是编写健壮 C# 代码的关键。 对于科学工作，优先使用 double，因为速度和范围比精确的小数更重要。 对于金融或货币任务，使用 decimal 以确保精度，尽管它会增加内存成本。 除非内存受到严重限制，否则避免使用 float，因为其较低的精度通常会导致问题。 始终使用后缀 (f, m) 并显式处理像 NaN 这样的特殊值以防止错误。

资料来源

作者

我的名字是 Jan Bodnar，我是一位热情的程序员，拥有丰富的编程经验。 我自 2007 年以来一直在撰写编程文章。 迄今为止，我已经撰写了 1,400 多篇文章和 8 本电子书。 我拥有超过十年的编程教学经验。

列出所有 C# 教程。