i8/i16/i32/i64/i128 有符号整数
什么是有符号整数
有符号整数是可以表示正数、负数和零的整数类型。Rust 提供了五种固定宽度的有符号整数类型,名字中的数字表示占用的位数(bit)。"有符号"意味着用一个 bit 来记录正负号,剩下的 bit 表示数值大小。
| 类型 | 位数 | 字节数 | 最小值 | 最大值 |
|---|---|---|---|---|
i8 | 8 | 1 | -128 | 127 |
i16 | 16 | 2 | -32,768 | 32,767 |
i32 | 32 | 4 | -2,147,483,648 | 2,147,483,647(约 21 亿) |
i64 | 64 | 8 | -9,223,372,036,854,775,808 | 9,223,372,036,854,775,807 |
i128 | 128 | 16 | -170,141,183,460,469,231,731,687,303,715,884,105,728 | 170,141,183,460,469,231,731,687,303,715,884,105,727 |
Rust 中整数字面量默认的类型是 i32。当你写 let x = 42; 的时候,x 的类型就是 i32。i32 在大多数场景下是性能和范围的最佳平衡点——在 32 位和 64 位 CPU 上都能高效处理。
基本声明和使用
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);
}基本算术运算
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 关键字显式转换。
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 范围
}
}常用方法
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(回绕)
}基本示例
计算一组数字的统计信息:
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 | 节省内存 |
| 需要极大数值 | i128 | 128 位范围 |
| 和 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 等安全方法代替普通运算符。