Rust 基本数据类型：从位级表示到内存安全的类型哲学

引言：类型系统的安全边界

在系统编程领域，基本数据类型不仅仅是存储数据的容器，更是内存安全、性能优化和程序正确性的第一道防线。Rust 通过精心设计的类型系统，将传统 C/C++ 中隐式的类型转换、未定义行为和溢出风险转化为编译时可检测的错误，这种"将 bug 前移"的设计哲学是 Rust 安全保证的基石。

整数类型：精确控制与溢出语义

Rust 提供了从 i8 到 i128 以及对应的无符号类型 u8 到 u128，这种显式的位宽声明消除了跨平台的歧义。不同于 C 语言中 int 的平台相关性，Rust 的整数类型具有确定的大小和表示范围，这使得代码在不同架构上的行为是可预测的。

更深层次的设计体现在溢出处理上。Rust 在 debug 模式下会对整数溢出进行 panic，而在 release 模式下采用二补数回绕（wrapping）语义。这种双模式设计在开发阶段暴露潜在错误，同时在生产环境保证性能。但 Rust 并未止步于此，它提供了 wrapping_add、saturating_mul、checked_div 等方法族，让开发者能够显式声明溢出语义，将隐式的运行时行为转化为显式的 API 选择。

浮点类型：IEEE 754 的忠实实现

Rust 的 f32 和 f64 严格遵循 IEEE 754 标准，但它在类型安全上做了关键改进：浮点数不实现 Eq trait，只实现 PartialEq。这个设计直指浮点运算的本质问题——NaN != NaN。通过类型系统强制开发者认识到浮点比较的非传递性，Rust 避免了无数因浮点特性误用而产生的隐蔽 bug。

布尔类型：单一字节的语义纯粹性

bool 类型在 Rust 中占用一个字节，只有 true 和 false 两个值。这种设计看似简单，却体现了类型安全的深刻思考：Rust 不允许将整数隐式转换为布尔值，也不允许布尔值参与算术运算。这种"语义纯粹性"消除了 C 语言中 if (x = 0) 这类经典错误，将控制流的条件判断限制在布尔领域。

实践深度：类型驱动的金融计算系统

以下案例展示了如何利用 Rust 类型系统构建一个安全的金融计算模块：

use std::ops::{Add, Sub, Mul, Div};

// 使用 newtype 模式封装货币类型
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
pub struct Money(i64); // 以分为单位存储，避免浮点误差

impl Money {
    pub fn from_yuan(yuan: f64) -> Result<Self, &'static str> {
        if !yuan.is_finite() {
            return Err("金额必须是有限数值");
        }
        // 使用 checked_mul 防止溢出
        let fen = (yuan * 100.0).round() as i64;
        if fen < 0 {
            return Err("金额不能为负");
        }
        Ok(Money(fen))
    }
    
    pub fn to_yuan(&self) -> f64 {
        self.0 as f64 / 100.0
    }
    
    // 安全的除法，返回 Option 处理除零情况
    pub fn divide_checked(&self, divisor: u32) -> Option<Self> {
        if divisor == 0 {
            return None;
        }
        Some(Money(self.0 / divisor as i64))
    }
}

impl Add for Money {
    type Output = Result<Money, &'static str>;
    
    fn add(self, rhs: Self) -> Self::Output {
        self.0.checked_add(rhs.0)
            .map(Money)
            .ok_or("金额加法溢出")
    }
}

// 利率计算：使用定点数避免浮点误差
#[derive(Debug, Clone, Copy)]
pub struct InterestRate {
    // 存储为万分比，例如 5.25% 存储为 525
    basis_points: u16,
}

impl InterestRate {
    pub fn from_percent(percent: f64) -> Result<Self, &'static str> {
        if percent < 0.0 || percent > 100.0 {
            return Err("利率必须在 0-100 之间");
        }
        let bp = (percent * 100.0).round() as u16;
        Ok(InterestRate { basis_points: bp })
    }
    
    pub fn apply_to(&self, principal: Money) -> Result<Money, &'static str> {
        let interest = principal.0
            .checked_mul(self.basis_points as i64)
            .and_then(|v| v.checked_div(10000))
            .ok_or("利息计算溢出")?;
        Ok(Money(interest))
    }
}

// 安全的百分比类型
#[derive(Debug, Clone, Copy)]
pub struct Percentage(u8); // 0-100

impl Percentage {
    pub fn new(value: u8) -> Result<Self, &'static str> {
        if value > 100 {
            return Err("百分比不能超过 100");
        }
        Ok(Percentage(value))
    }
    
    pub fn of(&self, total: u64) -> u64 {
        // 使用饱和乘法避免溢出
        total.saturating_mul(self.0 as u64) / 100
    }
}

// 温度类型：利用类型系统区分摄氏和华氏
#[derive(Debug, Clone, Copy)]
pub struct Celsius(f64);

#[derive(Debug, Clone, Copy)]
pub struct Fahrenheit(f64);

impl From<Celsius> for Fahrenheit {
    fn from(c: Celsius) -> Self {
        Fahrenheit(c.0 * 9.0 / 5.0 + 32.0)
    }
}

impl From<Fahrenheit> for Celsius {
    fn from(f: Fahrenheit) -> Self {
        Celsius((f.0 - 32.0) * 5.0 / 9.0)
    }
}

// 使用示例
fn calculate_investment_return() -> Result<(), &'static str> {
    let principal = Money::from_yuan(10000.0)?;
    let rate = InterestRate::from_percent(5.25)?;
    let interest = rate.apply_to(principal)?;
    
    println!("本金: {:.2} 元", principal.to_yuan());
    println!("利息: {:.2} 元", interest.to_yuan());
    
    // 类型安全：不能将 Celsius 和 Fahrenheit 直接比较
    let temp_c = Celsius(25.0);
    let temp_f: Fahrenheit = temp_c.into();
    println!("温度: {:.1}°C = {:.1}°F", temp_c.0, temp_f.0);
    
    Ok(())
}

专业思考：Newtype 模式的类型驱动设计

上述代码展现了几个关键的工程实践：

领域类型的封装：Money 类型使用整数存储货币值，避免了浮点数的精度问题。这种 newtype 模式不仅提供了类型安全（不会意外地将普通整数当作金额使用），还为业务逻辑提供了语义化的 API。通过实现 From、Add 等 trait，我们构建了一个既类型安全又符合 Rust 惯用法的抽象。

显式的错误处理：金额转换和计算都返回 Result，这迫使调用者处理可能的溢出、除零等错误。相比 C++ 中隐式的溢出或异常抛出，这种显式设计让错误路径在编译时就可见，大幅降低了运行时意外的可能性。

单位类型的区分：Celsius 和 Fahrenheit 虽然底层都是 f64，但通过 newtype 模式，编译器能防止错误的单位混用。这种"让非法状态不可表示"的设计思想，在物理计算、金融系统等领域具有极高的价值。NASA 曾因单位混用导致火星探测器坠毁，类似事故在 Rust 的类型系统下会在编译阶段被拦截。

溢出策略的显式化：通过 checked_add、saturating_mul 等方法，代码明确了每个运算的溢出语义。这种显式性不仅提升了代码的可读性，更重要的是让业务逻辑的边界条件成为了类型契约的一部分。

深入：内存布局与性能考量

Rust 的基本类型在内存中的布局是明确的：bool 占用 1 字节，i32 占用 4 字节并按 4 字节对齐。这种确定性使得 Rust 能够在保证安全的前提下实现零成本抽象。例如，Option<&T> 能够被优化为与指针相同的大小，因为编译器知道引用永远非空，可以用空指针表示 None。

在性能敏感的场景中，选择合适的整数类型至关重要。使用 u8 而非 u32 可以减少缓存未命中，但过度优化可能导致频繁的类型转换开销。Rust 的 as 转换是显式的，这提醒开发者注意潜在的截断风险。

结语

Rust 的基本数据类型设计体现了"安全第一，性能并重"的核心理念。通过将类型系统、所有权机制和显式语义相结合，Rust 在不牺牲性能的前提下，消除了系统编程中大量的未定义行为和隐蔽 bug。掌握这些基本类型不仅是学习 Rust 的起点,更是理解整个 Rust 生态设计哲学的关键。