f32 单精度浮点 ​

什么是 f32 ​

f32 是 Rust 的 32 位单精度浮点数类型,遵循 IEEE 754 标准。它占用 4 个字节,能表示带小数点的数字,包括正数、负数、零、正无穷、负无穷和 NaN(非数字)。

f32 提供大约 6-7 位有效十进制数字的精度。也就是说,超过 7 位有效数字后就会出现精度丢失。如果你需要更高的精度,应该用 f64。

rust
fn main() {
    // f32 需要显式标注类型,因为浮点数默认推断为 f64
    let x: f32 = 3.14;
    let y = 2.5f32;         // 用类型后缀指定为 f32
    let z: f32 = -0.001;

    println!("x = {}, y = {}, z = {}", x, y, z);

    // f32 的表示范围
    println!("最小正数:{}", f32::MIN_POSITIVE);  // 约 1.17549435e-38
    println!("最大值:{}", f32::MAX);              // 约 3.4028235e38
    println!("最小值:{}", f32::MIN);              // 约 -3.4028235e38
}

基本运算 ​

rust
fn main() {
    let a: f32 = 10.5;
    let b: f32 = 3.2;

    // 四则运算
    println!("{} + {} = {}", a, b, a + b);    // 13.7
    println!("{} - {} = {}", a, b, a - b);    // 7.3
    println!("{} * {} = {}", a, b, a * b);    // 33.6
    println!("{} / {} = {}", a, b, a / b);    // 3.28125
    println!("{} % {} = {}", a, b, a % b);    // 0.9000001(注意精度)

    // 浮点除以 0 不会 panic,而是返回无穷大
    let inf = 1.0f32 / 0.0;
    println!("1.0 / 0.0 = {}", inf);   // inf
    println!("-1.0 / 0.0 = {}", -1.0f32 / 0.0);  // -inf

    // 0 除以 0 返回 NaN
    let nan = 0.0f32 / 0.0;
    println!("0.0 / 0.0 = {}", nan);   // NaN
}

常用数学方法 ​

rust
fn main() {
    let x: f32 = 2.7;

    // 取整
    println!("floor(2.7) = {}", x.floor());    // 2.0(向下取整)
    println!("ceil(2.7) = {}", x.ceil());      // 3.0(向上取整)
    println!("round(2.7) = {}", x.round());    // 3.0(四舍五入)
    println!("trunc(2.7) = {}", x.trunc());    // 2.0(截断小数部分)

    // 绝对值
    let neg: f32 = -5.3;
    println!("abs(-5.3) = {}", neg.abs());     // 5.3

    // 幂和开方
    println!("2.0^3 = {}", 2.0f32.powf(3.0));       // 8.0
    println!("2.0^3 = {}", 2.0f32.powi(3));          // 8.0(整数幂,更快)
    println!("sqrt(9.0) = {}", 9.0f32.sqrt());       // 3.0
    println!("cbrt(27.0) = {}", 27.0f32.cbrt());     // 3.0(立方根)

    // 三角函数
    let pi: f32 = std::f32::consts::PI;
    println!("sin(PI/2) = {}", (pi / 2.0).sin());    // 1.0
    println!("cos(0) = {}", 0.0f32.cos());            // 1.0

    // 对数和指数
    println!("ln(e) = {}", std::f32::consts::E.ln());     // 1.0
    println!("log2(8) = {}", 8.0f32.log2());               // 3.0
    println!("log10(1000) = {}", 1000.0f32.log10());       // 3.0

    // 最大值和最小值
    println!("max(3.0, 5.0) = {}", 3.0f32.max(5.0));  // 5.0
    println!("min(3.0, 5.0) = {}", 3.0f32.min(5.0));  // 3.0

    // 限制在范围内
    println!("clamp(15.0, 0.0, 10.0) = {}", 15.0f32.clamp(0.0, 10.0));  // 10.0
}

特殊值 ​

rust
fn main() {
    // 正无穷和负无穷
    let pos_inf = f32::INFINITY;
    let neg_inf = f32::NEG_INFINITY;
    println!("正无穷:{}", pos_inf);
    println!("负无穷:{}", neg_inf);

    // NaN(Not a Number)
    let nan = f32::NAN;
    println!("NaN: {}", nan);

    // NaN 的特殊性质:NaN 不等于任何值,包括自己
    println!("NaN == NaN: {}", nan == nan);      // false
    println!("NaN != NaN: {}", nan != nan);      // true

    // 检测特殊值
    println!("is_nan: {}", nan.is_nan());                 // true
    println!("is_infinite: {}", pos_inf.is_infinite());   // true
    println!("is_finite: {}", 3.14f32.is_finite());       // true
    println!("is_normal: {}", 3.14f32.is_normal());       // true
    println!("is_normal(0.0): {}", 0.0f32.is_normal());   // false(0 不是 normal)
}

精度问题 ​

rust
fn main() {
    // f32 的精度有限,某些十进制小数无法精确表示
    let x: f32 = 0.1;
    let y: f32 = 0.2;
    let sum = x + y;
    println!("0.1 + 0.2 = {:.20}", sum);  // 0.30000001192092895508(不是精确的 0.3)

    // 所以不要用 == 直接比较浮点数
    println!("0.1 + 0.2 == 0.3: {}", sum == 0.3);  // false

    // 正确的比较方式:检查差值是否在一个很小的范围内
    let epsilon: f32 = 1e-6;
    let is_close = (sum - 0.3).abs() < epsilon;
    println!("近似相等:{}", is_close);  // true

    // f32 的有效精度大约 7 位十进制数字
    let precise: f32 = 1234567.0;
    let imprecise: f32 = 12345678.0;
    println!("1234567.0 as f32 = {}", precise);      // 精确
    println!("12345678.0 as f32 = {}", imprecise);   // 可能有精度丢失
}

基本示例 ​

计算二维空间中两点之间的距离:

rust
// 表示二维平面上的点
struct Point {
    x: f32,
    y: f32,
}

impl Point {
    // 计算到另一个点的距离
    fn distance_to(&self, other: &Point) -> f32 {
        let dx = self.x - other.x;
        let dy = self.y - other.y;
        // hypot 方法比手动 sqrt(dx*dx + dy*dy) 更精确,不容易溢出
        dx.hypot(dy)
    }
}

fn main() {
    let p1 = Point { x: 0.0, y: 0.0 };
    let p2 = Point { x: 3.0, y: 4.0 };

    let dist = p1.distance_to(&p2);
    println!("({}, {}) 到 ({}, {}) 的距离:{}", p1.x, p1.y, p2.x, p2.y, dist);
    // 输出 5.0(经典的 3-4-5 直角三角形)
}

常见问题 ​

问题一:什么时候用 f32,什么时候用 f64?

选择适用场景理由
f64大多数场景(默认)精度更高(15-16 位),现代 CPU 处理 f64 和 f32 一样快
f32图形编程、游戏开发GPU 更擅长处理 f32,节省显存
f32大量数据存储内存占用少一半
f32和 C 的 float 交互C 的 float 对应 f32

问题二:为什么浮点数不能做 HashMap 的 key?

因为 f32 和 f64 没有实现 Eq 和 Hash trait。原因是 NaN != NaN,这违反了 Eq 的自反性要求。如果确实需要浮点数做 key,可以用 ordered_float 这个第三方 crate。

问题三:浮点数溢出会怎样?

不会 panic。超过最大值变成 inf(正无穷),低于最小负数变成 -inf。inf 参与运算会传播:inf + 1.0 还是 inf。

问题四:f32 和 i32 之间怎么转换?

rust
fn main() {
    let f: f32 = 3.99;
    let i: i32 = f as i32;      // 截断小数部分,得到 3(不是四舍五入)
    println!("3.99 as i32 = {}", i);

    let n: i32 = 42;
    let f: f32 = n as f32;      // 整数转浮点,可能丢失精度(大整数时)
    println!("42 as f32 = {}", f);
}

适用场景 ​

  • 图形和游戏开发:顶点坐标、颜色值、纹理坐标等,GPU 原生支持 f32
  • 音频处理:采样值通常用 f32 表示
  • 机器学习推理:模型权重在推理阶段常用 f32(甚至更低精度)
  • 传感器数据:温度、湿度等物理量的精度要求不高
  • 和 C 代码交互:C 的 float 类型对应 Rust 的 f32
  • 大规模数据存储:相比 f64 节省一半内存

注意事项 ​

  • 浮点数字面量默认类型是 f64,要用 f32 需要标注或用后缀 f32
  • 不要用 == 直接比较两个浮点数是否相等,应该检查差值是否小于一个很小的阈值
  • NaN 不等于任何值包括自己,判断是否是 NaN 用 is_nan() 方法
  • f32 和整数类型不能直接运算,需要用 as 显式转换
  • as 转换浮点数到整数时是截断而不是四舍五入,如果要四舍五入先调用 .round()
  • 浮点数除以 0 不会 panic,而是返回 inf 或 NaN
  • 不要用 f32 表示金额,累积的精度误差会导致金额不对,用整数(以"分"为单位)更可靠

总结 ​

f32 是 32 位单精度浮点数,提供约 6-7 位有效数字精度,适用于对精度要求不高但对内存占用敏感的场景,比如图形编程和大规模数据处理。它支持完整的数学运算(三角函数、对数、幂等)和特殊值(inf、NaN)。使用 f32 时最需要注意的是精度问题——不要用 == 比较浮点数,不要用它存储金额。在大多数通用计算场景中,优先选择精度更高的 f64。