u8/u16/u32/u64/u128 无符号整数
什么是无符号整数
无符号整数只能表示零和正数,不能表示负数。因为不需要用一个 bit 来记录正负号,同样的位数可以表示更大的正数范围。Rust 提供了五种固定宽度的无符号整数类型。
| 类型 | 位数 | 字节数 | 最小值 | 最大值 |
|---|---|---|---|---|
u8 | 8 | 1 | 0 | 255 |
u16 | 16 | 2 | 0 | 65,535 |
u32 | 32 | 4 | 0 | 4,294,967,295(约 42 亿) |
u64 | 64 | 8 | 0 | 18,446,744,073,709,551,615 |
u128 | 128 | 16 | 0 | 340,282,366,920,938,463,463,374,607,431,768,211,455 |
和有符号整数相比,同样的位数下,无符号整数的最大值大约是有符号整数的两倍。比如 u8 最大 255,而 i8 最大 127。
基本声明和使用
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 密切相关。
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
}无符号整数与减法陷阱
无符号整数最容易出问题的地方是减法——结果不能为负。
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
}类型转换
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
}
}常用方法
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
}基本示例
统计一段文本中每个字节值出现的次数:
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 等安全方法来避免。