isize/usize 指针尺寸整数 ​

什么是 isize 和 usize ​

isize 和 usize 是两种特殊的整数类型,它们的位数不是固定的,而是跟着目标平台的指针大小走。在 32 位系统上它们是 32 位,在 64 位系统上它们是 64 位。

类型符号性32 位系统64 位系统
usize无符号等同于 u32(0 ~ 4,294,967,295)等同于 u64(0 ~ 18,446,744,073,709,551,615)
isize有符号等同于 i32等同于 i64

usize 是 Rust 中最常用的整数类型之一,因为它是数组索引、集合长度、内存大小的标准类型。你写 vec.len() 返回的就是 usize,写 array[i] 时 i 必须是 usize。

为什么需要平台相关的整数类型 ​

数组索引本质上是内存偏移量,而内存地址空间的大小取决于 CPU 架构。32 位系统最多寻址 4GB 内存,所以索引用 32 位就够了;64 位系统的地址空间大得多,索引需要 64 位。usize 自动适配平台,保证既不浪费空间也不会范围不够。

rust
fn main() {
    // usize 的大小取决于平台
    println!("usize 占 {} 字节", std::mem::size_of::<usize>());
    // 64 位系统输出:8
    // 32 位系统输出:4

    println!("isize 占 {} 字节", std::mem::size_of::<isize>());

    // usize 的范围
    println!("usize 范围:{} ~ {}", usize::MIN, usize::MAX);
    println!("isize 范围:{} ~ {}", isize::MIN, isize::MAX);
}

usize 作为索引类型 ​

Rust 强制要求数组和切片的索引必须是 usize 类型。用其他类型索引需要先转换。

rust
fn main() {
    let fruits = ["苹果", "香蕉", "橙子", "葡萄", "西瓜"];

    // usize 可以直接用作索引
    let index: usize = 2;
    println!("第 {} 个水果:{}", index, fruits[index]);

    // i32 不能直接用作索引,需要转换
    let i: i32 = 3;
    // println!("{}", fruits[i]);  // 编译错误:the type `[&str]` cannot be indexed by `i32`
    println!("{}", fruits[i as usize]);  // 需要转成 usize

    // vec.len() 返回 usize
    let numbers = vec![10, 20, 30, 40, 50];
    let length: usize = numbers.len();
    println!("长度:{}", length);

    // 遍历索引
    for i in 0..numbers.len() {
        // i 的类型自动是 usize
        println!("numbers[{}] = {}", i, numbers[i]);
    }
}

usize 与其他整数类型的转换 ​

rust
fn main() {
    // 从 i32/u32 转到 usize
    let a: i32 = 42;
    let b: u32 = 100;
    let idx_a: usize = a as usize;   // 正数没问题
    let idx_b: usize = b as usize;   // u32 -> usize 在 64 位系统上是安全的
    println!("idx_a = {}, idx_b = {}", idx_a, idx_b);

    // 负数转 usize 会出问题
    let negative: i32 = -1;
    let bad_index: usize = negative as usize;
    println!("-1 as usize = {}", bad_index);  // 一个非常大的数(usize::MAX)

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

    // 从 usize 转到固定宽度类型
    let size: usize = 1000;
    let as_u32: u32 = size as u32;  // 在 64 位系统上可能截断
    println!("usize -> u32: {}", as_u32);

    // 安全转换
    let big_size: usize = 5_000_000_000;
    match u32::try_from(big_size) {
        Ok(v) => println!("转换成功:{}", v),
        Err(e) => println!("转换失败(超出 u32 范围):{}", e),
    }
}

isize 的用途 ​

isize 用得比 usize 少很多。它主要出现在需要有符号偏移量的场景,比如指针运算。

rust
fn main() {
    // isize 最常见于指针偏移
    let data = [10, 20, 30, 40, 50];
    let ptr = data.as_ptr();

    unsafe {
        // offset 方法的参数是 isize,可以正也可以负
        let third = *ptr.offset(2);   // 向后偏移 2 个元素
        println!("第三个元素:{}", third);  // 30
    }

    // isize 也可以表示有符号的差值
    let start: usize = 10;
    let end: usize = 3;
    // 用 isize 表示位移方向
    let delta: isize = end as isize - start as isize;  // -7
    println!("位移:{}", delta);
}

基本示例 ​

一个使用 usize 的实际场景——在数组中查找元素并返回索引:

rust
// 在切片中查找目标值,返回第一个匹配的索引
// 返回 Option<usize>,因为索引类型是 usize
fn find_index(slice: &[i32], target: i32) -> Option<usize> {
    for (index, &value) in slice.iter().enumerate() {
        // enumerate() 返回的索引是 usize 类型
        if value == target {
            return Some(index);
        }
    }
    None
}

// 计算两个索引之间的距离
fn index_distance(a: usize, b: usize) -> usize {
    // 用 abs_diff 避免无符号减法溢出
    a.abs_diff(b)
}

fn main() {
    let numbers = [15, 42, 8, 23, 42, 16, 7];

    match find_index(&numbers, 42) {
        Some(idx) => println!("42 第一次出现在索引 {}", idx),
        None => println!("没找到"),
    }

    match find_index(&numbers, 99) {
        Some(idx) => println!("99 在索引 {}", idx),
        None => println!("99 不在数组中"),
    }

    // 计算两个位置之间的距离
    let pos_a: usize = 2;
    let pos_b: usize = 6;
    println!("索引 {} 和 {} 之间的距离:{}", pos_a, pos_b, index_distance(pos_a, pos_b));
}

常见问题 ​

问题一:为什么不直接用 u64 做索引?

在 32 位系统上,u64 比指针大,用 u64 做索引会浪费内存且可能需要额外的转换开销。usize 跟着平台走,保证既不浪费也不不够用。更重要的是,Rust 标准库的 API 统一使用 usize,如果你用别的类型,到处都要做类型转换。

问题二:usize 和 u32/u64 之间转换安全吗?

转换方向32 位系统64 位系统
u32 -> usize安全(大小相同)安全(扩展)
u64 -> usize可能截断安全(大小相同)
usize -> u32安全(大小相同)可能截断
usize -> u64安全(扩展)安全(大小相同)

不确定时用 TryFrom / TryInto 做安全转换。

问题三:写跨平台代码时要注意什么?

如果你的代码需要同时在 32 位和 64 位平台运行,不要假设 usize 的大小。比如不要把 usize 值序列化到文件或网络中(因为不同平台上大小不同),应该用固定宽度的类型如 u64。

问题四:as usize 转换负数会怎样?

负数用 as usize 转换会得到一个非常大的正数(因为补码表示直接被解释为无符号值)。这几乎总是 bug。对可能为负的值应该先检查再转换,或者用 TryFrom。

适用场景 ​

  • 数组和切片索引:array[i] 中 i 必须是 usize
  • 集合的长度和容量:vec.len()、vec.capacity() 返回 usize
  • 内存大小计算:std::mem::size_of::<T>() 返回 usize
  • 迭代器的计数:iter.count()、iter.enumerate() 中的索引都是 usize
  • 指针偏移:ptr.offset() 的参数是 isize
  • 和 C 代码交互中的 size_t:C 的 size_t 对应 Rust 的 usize

注意事项 ​

  • usize 是 Rust 中索引的唯一合法类型,用其他整数类型索引必须先转成 usize
  • 不要假设 usize 的具体大小(32 还是 64 位),写跨平台代码时要注意
  • 负数转 usize 会得到错误的大数值,一定要在转换前检查
  • 序列化数据时不要直接用 usize,应该转成固定宽度的类型(如 u64)
  • isize 的使用场景比 usize 少得多,主要在指针运算和底层代码中出现
  • abs_diff 方法可以安全计算两个 usize 的差的绝对值,避免减法溢出
  • 在 for 循环中,0..n 如果 n 是 usize 类型,循环变量自动也是 usize

总结 ​

usize 和 isize 是平台相关的整数类型,大小等于目标系统的指针宽度(32 位或 64 位)。usize 是 Rust 中数组索引和集合长度的标准类型,日常开发中使用频率很高。isize 主要用于指针偏移等有符号的底层操作。和固定宽度类型之间转换时要注意平台差异可能导致的截断问题,不确定时用 TryFrom 做安全转换。在跨平台代码和序列化场景中,应该使用固定宽度的整数类型而不是 usize / isize。