u8/u16/u32/u64/u128 无符号整数 ​

什么是无符号整数 ​

无符号整数只能表示零和正数,不能表示负数。因为不需要用一个 bit 来记录正负号,同样的位数可以表示更大的正数范围。Rust 提供了五种固定宽度的无符号整数类型。

类型位数字节数最小值最大值
u8810255
u16162065,535
u3232404,294,967,295(约 42 亿)
u64648018,446,744,073,709,551,615
u128128160340,282,366,920,938,463,463,374,607,431,768,211,455

和有符号整数相比,同样的位数下,无符号整数的最大值大约是有符号整数的两倍。比如 u8 最大 255,而 i8 最大 127。

基本声明和使用 ​

rust
fn main() {
    // 显式类型标注
    let age: u8 = 25;             // 年龄用 u8 够了(0-255)
    let port: u16 = 8080;         // 端口号范围 0-65535,刚好 u16
    let population: u32 = 1_400_000_000;  // 人口数
    let file_size: u64 = 10_737_418_240;  // 文件大小(字节),10GB
    let huge: u128 = u128::MAX;

    println!("年龄:{}", age);
    println!("端口:{}", port);
    println!("人口:{}", population);
    println!("文件大小:{} 字节", file_size);
    println!("u128 最大值:{}", huge);

    // 类型后缀
    let a = 100u8;
    let b = 50000u32;
    let c = 42u64;
    println!("a={}, b={}, c={}", a, b, c);
}

u8 与字节操作 ​

u8 在 Rust 中有特殊地位——它是字节(byte)的别名。文件 IO、网络传输、字符串的底层表示都和 u8 密切相关。

rust
fn main() {
    // 字符串的底层是 u8 的序列(UTF-8 编码)
    let s = "Hello";
    let bytes: &[u8] = s.as_bytes();
    println!("字符串的字节:{:?}", bytes);  // [72, 101, 108, 108, 111]

    // 字节字面量:用 b 前缀
    let newline: u8 = b'\n';     // 换行符的 ASCII 值:10
    let letter_a: u8 = b'A';    // 大写 A 的 ASCII 值:65
    println!("换行符:{},A:{}", newline, letter_a);

    // 字节字符串
    let byte_str: &[u8] = b"Hello";
    println!("字节字符串:{:?}", byte_str);

    // u8 可以转成字符
    let code: u8 = 65;
    let ch = code as char;
    println!("ASCII {} 对应字符:{}", code, ch);  // A

    // 位运算在 u8 上很常用
    let flags: u8 = 0b1010_0101;  // 二进制字面量
    println!("标志位:{:08b}", flags);         // 10100101
    println!("第 0 位:{}", flags & 1);        // 1
    println!("第 1 位:{}", (flags >> 1) & 1); // 0
}

无符号整数与减法陷阱 ​

无符号整数最容易出问题的地方是减法——结果不能为负。

rust
fn main() {
    let a: u32 = 5;
    let b: u32 = 3;

    // 正常减法没问题
    let diff = a - b;
    println!("5 - 3 = {}", diff);  // 2

    // 但如果结果会是负数...
    // let bad = b - a;  // Debug 模式下会 panic:attempt to subtract with overflow
                         // Release 模式下会回绕:4294967294

    // 安全的做法:先检查再减
    if a >= b {
        println!("差值:{}", a - b);
    } else {
        println!("a 小于 b,不能做无符号减法");
    }

    // 或者用 checked_sub
    let result = b.checked_sub(a);
    match result {
        Some(v) => println!("结果:{}", v),
        None => println!("会溢出,返回 None"),
    }

    // 或者用 saturating_sub(饱和到 0)
    let safe = b.saturating_sub(a);
    println!("饱和减法:3 - 5 = {}", safe);  // 0
}

类型转换 ​

rust
fn main() {
    // 无符号之间转换
    let small: u8 = 200;
    let big: u32 = small as u32;   // 小转大,安全
    println!("u8 -> u32: {}", big);

    let large: u32 = 300;
    let truncated: u8 = large as u8;  // 大转小,截断
    println!("300 as u8 = {}", truncated);  // 44(300 % 256)

    // 有符号和无符号之间转换
    let positive: i32 = 42;
    let as_unsigned: u32 = positive as u32;  // 正数转无符号没问题
    println!("i32(42) -> u32: {}", as_unsigned);

    let negative: i32 = -1;
    let as_unsigned: u32 = negative as u32;  // 负数转无符号会得到很大的数
    println!("i32(-1) -> u32: {}", as_unsigned);  // 4294967295(u32::MAX)

    // 安全转换
    use std::convert::TryFrom;
    let val: i32 = -5;
    match u32::try_from(val) {
        Ok(v) => println!("转换成功:{}", v),
        Err(e) => println!("转换失败:{}", e),  // 负数不能转成 u32
    }
}

常用方法 ​

rust
fn main() {
    // 类型的边界值
    println!("u8:  {} ~ {}", u8::MIN, u8::MAX);     // 0 ~ 255
    println!("u32: {} ~ {}", u32::MIN, u32::MAX);   // 0 ~ 4294967295
    println!("u64: {} ~ {}", u64::MIN, u64::MAX);

    // 位数和字节数
    println!("u32 占 {} 位,{} 字节", u32::BITS, std::mem::size_of::<u32>());

    // 二进制中 1 的个数
    let n: u32 = 0b1010_1100;
    println!("{:08b} 中有 {} 个 1", n, n.count_ones());   // 4
    println!("{:08b} 中有 {} 个 0", n, n.count_zeros());  // 28

    // 前导零和尾随零
    let m: u32 = 0b0000_1000;
    println!("前导零:{}", m.leading_zeros());   // 28
    println!("尾随零:{}", m.trailing_zeros());  // 3

    // 幂运算
    let base: u32 = 2;
    println!("2^10 = {}", base.pow(10));  // 1024

    // 对数(以 2 为底,向下取整)
    let val: u32 = 1000;
    println!("log2(1000) = {}", val.ilog2());  // 9

    // 下一个 2 的幂
    let x: u32 = 100;
    println!("100 的下一个 2 的幂:{}", x.next_power_of_two());  // 128
}

基本示例 ​

统计一段文本中每个字节值出现的次数:

rust
fn main() {
    let text = "Hello, Rust! 你好,世界!";

    // 用 u8 索引的数组作为计数器
    // 256 个位置对应 0-255 的所有可能字节值
    let mut byte_count = [0u32; 256];

    // 遍历文本的每个字节
    for &byte in text.as_bytes() {
        // byte 是 u8 类型,可以直接作为数组索引(需要转成 usize)
        byte_count[byte as usize] += 1;
    }

    // 打印出现过的字节及其次数
    println!("文本:{}", text);
    println!("字节分布:");
    for (byte_val, &count) in byte_count.iter().enumerate() {
        if count > 0 {
            // 判断是否是可打印的 ASCII 字符
            if byte_val >= 32 && byte_val < 127 {
                println!("  '{}' (0x{:02X}) 出现 {} 次",
                    byte_val as u8 as char, byte_val, count);
            } else {
                println!("  0x{:02X} 出现 {} 次", byte_val, count);
            }
        }
    }

    println!("总字节数:{}", text.as_bytes().len());
}

常见问题 ​

问题一:什么时候用无符号,什么时候用有符号?

选择适用场景理由
无符号 u*天然不会为负的量:年龄、大小、计数、端口号语义更清晰,范围更大
有符号 i*可能为负的量:温度差、位移、利润、通用计算减法结果可能为负
i32不确定时的默认选择Rust 默认类型,通用性好
usize数组索引、集合大小Rust 标准库的要求

问题二:u32 和 usize 有什么区别?

u32 固定是 32 位。usize 的大小取决于目标平台——32 位系统上是 32 位,64 位系统上是 64 位。usize 主要用于数组索引和内存相关的操作,其他场景一般用固定宽度的类型。

问题三:无符号减法溢出了会怎样?

Debug 模式下程序会 panic。Release 模式下会回绕(wrapping):0u32 - 1 得到 4294967295(u32::MAX)。这两种行为都不是你想要的,所以对可能溢出的减法应该用 checked_sub 或 saturating_sub。

问题四:为什么 Rust 数组索引必须用 usize?

因为数组索引代表的是内存偏移量,它的合理范围和系统的内存地址空间大小一致,而 usize 正好就是跟着系统架构走的。用固定宽度的类型可能在某些平台上不够大或浪费空间。

适用场景 ​

  • 字节操作:文件读写、网络数据包解析(u8)
  • 端口号:范围 0-65535(u16)
  • 颜色值:RGB 各通道 0-255(u8)
  • 哈希值:u32 或 u64
  • 文件大小:字节数(u64)
  • 时间戳:Unix 时间戳毫秒级(u64)
  • 唯一 ID:u64 或 u128
  • 位标志:用 u8/u16/u32 的每一位表示一个开关

注意事项 ​

  • 无符号类型做减法一定要注意溢出,a - b 在 b > a 时会出问题
  • 不要用 as 把负数转成无符号类型,结果会是一个很大的正数
  • 循环中如果用无符号类型倒数到 0,while n > 0 { n -= 1; } 是安全的,但 for i in (0..n).rev() 更地道
  • u8 到 char 的转换只对 ASCII 范围(0-127)有意义,128-255 虽然能转但可能不是你想要的字符
  • 在性能方面,u32 和 u64 在 64 位系统上差别很小,选哪个主要看值的范围
  • 和有符号类型混用时必须显式转换,编译器不会自动转

总结 ​

Rust 的无符号整数类型 u8、u16、u32、u64、u128 只能表示非负整数,相同位数下比有符号类型的正数范围更大。u8 作为字节类型在文件 IO 和字符串底层操作中使用频繁。选择无符号类型时主要依据值的含义(是否可能为负)和范围。无符号类型最需要注意的是减法溢出问题——当被减数小于减数时结果会回绕而不是变成负数,应该用 checked_sub 或 saturating_sub 等安全方法来避免。