i8/i16/i32/i64/i128 有符号整数 ​

什么是有符号整数 ​

有符号整数是可以表示正数、负数和零的整数类型。Rust 提供了五种固定宽度的有符号整数类型,名字中的数字表示占用的位数(bit)。"有符号"意味着用一个 bit 来记录正负号,剩下的 bit 表示数值大小。

类型位数字节数最小值最大值
i881-128127
i16162-32,76832,767
i32324-2,147,483,6482,147,483,647(约 21 亿)
i64648-9,223,372,036,854,775,8089,223,372,036,854,775,807
i12812816-170,141,183,460,469,231,731,687,303,715,884,105,728170,141,183,460,469,231,731,687,303,715,884,105,727

Rust 中整数字面量默认的类型是 i32。当你写 let x = 42; 的时候,x 的类型就是 i32。i32 在大多数场景下是性能和范围的最佳平衡点——在 32 位和 64 位 CPU 上都能高效处理。

基本声明和使用 ​

rust
fn main() {
    // 默认类型是 i32
    let a = 42;          // 类型推断为 i32
    let b: i8 = -100;    // 显式指定为 i8
    let c: i16 = 30000;  // 显式指定为 i16
    let d: i64 = 9_000_000_000;  // 下划线分隔,方便阅读
    let e: i128 = 170_141_183_460_469_231_731_687_303_715_884_105_727;

    println!("i32: {}", a);
    println!("i8: {}", b);
    println!("i16: {}", c);
    println!("i64: {}", d);
    println!("i128: {}", e);

    // 用类型后缀指定类型(不需要类型标注)
    let f = 42i64;     // 等同于 let f: i64 = 42;
    let g = -128i8;    // 等同于 let g: i8 = -128;
    println!("i64: {}, i8: {}", f, g);
}

基本算术运算 ​

rust
fn main() {
    let a: i32 = 100;
    let b: i32 = 30;

    // 基本四则运算和取余
    let sum = a + b;        // 加法:130
    let diff = a - b;       // 减法:70
    let product = a * b;    // 乘法:3000
    let quotient = a / b;   // 整数除法:3(向零截断,不是四舍五入)
    let remainder = a % b;  // 取余:10

    println!("加:{}", sum);
    println!("减:{}", diff);
    println!("乘:{}", product);
    println!("除:{}", quotient);   // 注意是整数除法
    println!("余:{}", remainder);

    // 负数的除法和取余
    let x = -7;
    let y = 2;
    println!("-7 / 2 = {}", x / y);   // -3(向零截断)
    println!("-7 % 2 = {}", x % y);   // -1(余数符号跟被除数一致)
}

类型转换 ​

不同位数的整数之间不能直接运算,需要用 as 关键字显式转换。

rust
fn main() {
    let small: i8 = 42;
    let big: i32 = 1000;

    // 小类型转大类型:安全,不会丢失数据
    let small_as_i32 = small as i32;
    let result = small_as_i32 + big;
    println!("{} + {} = {}", small, big, result);

    // 大类型转小类型:可能溢出截断
    let large: i32 = 300;
    let truncated: i8 = large as i8;
    // 300 超过了 i8 的范围(-128 到 127),会被截断
    println!("300 转成 i8 = {}", truncated);  // 44(300 % 256 = 44)

    // 使用 try_into() 进行安全转换(失败时返回 Err)
    use std::convert::TryInto;
    let value: i32 = 200;
    let safe_convert: Result<i8, _> = value.try_into();
    match safe_convert {
        Ok(v) => println!("转换成功:{}", v),
        Err(e) => println!("转换失败:{}", e),  // 200 超出 i8 范围
    }
}

常用方法 ​

rust
fn main() {
    // 获取类型的最大值和最小值
    println!("i8  范围:{} ~ {}", i8::MIN, i8::MAX);
    println!("i32 范围:{} ~ {}", i32::MIN, i32::MAX);
    println!("i64 范围:{} ~ {}", i64::MIN, i64::MAX);

    // 绝对值
    let n: i32 = -42;
    println!("{} 的绝对值:{}", n, n.abs());

    // 幂运算(pow 参数是 u32 类型)
    let base: i32 = 2;
    println!("2 的 10 次方:{}", base.pow(10));  // 1024

    // 判断正负零
    let val: i32 = -5;
    println!("是正数:{}", val.is_positive());   // false
    println!("是负数:{}", val.is_negative());   // true

    // 安全算术方法(不会 panic)
    let x: i32 = i32::MAX;
    println!("checked_add: {:?}", x.checked_add(1));       // None(溢出)
    println!("saturating_add: {}", x.saturating_add(1));    // 2147483647(饱和)
    println!("wrapping_add: {}", x.wrapping_add(1));        // -2147483648(回绕)
}

基本示例 ​

计算一组数字的统计信息:

rust
fn main() {
    let numbers: [i32; 8] = [15, -3, 42, 8, -17, 23, 0, 56];

    // 求和
    let mut sum: i64 = 0;  // 用 i64 避免求和时溢出
    for &n in &numbers {
        sum += n as i64;
    }

    // 计算平均值(整数除法)
    let count = numbers.len() as i64;
    let average = sum / count;

    // 找最大值和最小值
    let mut max = numbers[0];
    let mut min = numbers[0];
    for &n in &numbers {
        if n > max { max = n; }
        if n < min { min = n; }
    }

    // 统计正数和负数的个数
    let positive_count = numbers.iter().filter(|&&n| n > 0).count();
    let negative_count = numbers.iter().filter(|&&n| n < 0).count();

    println!("数组:{:?}", numbers);
    println!("总和:{}", sum);
    println!("平均值:{}", average);
    println!("最大值:{}", max);
    println!("最小值:{}", min);
    println!("正数 {} 个,负数 {} 个", positive_count, negative_count);
}

常见问题 ​

问题一:什么时候该选哪种整数类型?

场景推荐类型原因
一般整数运算i32默认类型,性能和范围平衡好
数组索引usize(无符号)Rust 的索引类型是 usize
文件大小、时间戳i64数值范围大,避免溢出
存储空间敏感(大量数据)i8 / i16节省内存
需要极大数值i128128 位范围
和 C 代码交互看 C 端的类型c_int 通常对应 i32

问题二:为什么不同类型不能直接运算?

这是 Rust 的类型安全设计。不同位数的整数混合运算时,自动转换可能导致精度丢失或溢出,Rust 要求你用 as 显式转换,强迫你思考转换是否安全。

问题三:整数除以零会怎样?

编译期能确定除以零的情况会在编译时报错。运行时除以零会直接 panic(程序崩溃),不是返回某个特殊值。

问题四:i32 和 i64 在性能上有差别吗?

在 64 位系统上,i32 和 i64 的基本运算性能几乎没区别。在 32 位系统上,i64 的运算需要两条指令完成,会慢一些。i128 在所有主流平台上都需要编译器用软件模拟,性能比原生类型差。

适用场景 ​

  • 通用计算:i32 覆盖绝大多数日常计算需求
  • 金融计算:用 i64 表示以"分"为单位的金额,避免浮点数精度问题
  • 科学计算:大数值范围的场景可以考虑 i128
  • 网络协议:根据协议规范选择对应位数的类型
  • 嵌入式开发:内存紧张时用 i8、i16 节省空间
  • 数据库交互:根据数据库字段类型选择对应的 Rust 类型

注意事项 ​

  • 整数字面量的默认类型是 i32,如果需要其他类型必须标注或使用后缀
  • 不同类型的整数不能直接混合运算,需要用 as 显式转换
  • as 转换在大转小时会静默截断,不会报错。需要安全转换时用 TryInto
  • Debug 模式下整数溢出会 panic,Release 模式下会回绕(wrapping)。不要依赖这个行为
  • 下划线分隔符 1_000_000 只是视觉上方便阅读,不影响值
  • i128 的性能比其他整数类型差,因为大多数 CPU 没有原生的 128 位运算指令
  • Rust 的整数没有隐式转换,这和 C/C++ 不同,需要适应

总结 ​

Rust 提供了 i8、i16、i32、i64、i128 五种有符号整数类型,分别对应 8 到 128 位的宽度。i32 是默认类型,适合大多数通用计算场景。不同类型的整数不能直接运算,需要用 as 显式转换,这是 Rust 类型安全的体现。选择整数类型时主要考虑值的范围和内存占用:范围够用就选小的,存储量大就选省空间的,不确定就用 i32。对于可能溢出的运算,应该使用 checked_add、saturating_add 等安全方法代替普通运算符。