整数字面量与类型后缀
什么是整数字面量
整数字面量就是你在代码中直接写的数字,比如 42、0xFF、0b1010。Rust 支持多种进制的字面量写法,并且允许在数字中间插入下划线来提高可读性。
各种进制的写法
rust
fn main() {
// 十进制(默认,最常用)
let decimal = 255;
// 十六进制:以 0x 开头
// 常用于颜色值、内存地址、位掩码
let hex = 0xFF; // 等于十进制 255
let hex2 = 0xff; // 大小写都行
let color = 0xRRGGBB; // 这行只是示意,实际不能用字母 R/G
let real_color = 0xFF8800; // 橙色
// 八进制:以 0o 开头
// 常用于 Unix 文件权限
let octal = 0o377; // 等于十进制 255
let permission = 0o755; // Unix 文件权限 rwxr-xr-x
// 二进制:以 0b 开头
// 常用于位操作、标志位
let binary = 0b1111_1111; // 等于十进制 255
let flags = 0b0000_1010; // 第 1 位和第 3 位为 1
// 字节字面量:b'字符',类型固定为 u8
let byte = b'A'; // 等于 65(A 的 ASCII 值)
let newline = b'\n'; // 等于 10
println!("十进制:{}", decimal);
println!("十六进制:{}", hex);
println!("八进制:{}", octal);
println!("二进制:{}", binary);
println!("字节:{}", byte);
// 用格式化输出查看不同进制的表示
let num = 255;
println!("十进制:{}", num);
println!("十六进制(小写):0x{:x}", num);
println!("十六进制(大写):0x{:X}", num);
println!("八进制:0o{:o}", num);
println!("二进制:0b{:b}", num);
println!("二进制(补零到 8 位):0b{:08b}", num);
}下划线分隔符
Rust 允许在数字字面量中间插入下划线 _,纯粹是为了方便人类阅读,编译器会忽略它们。
rust
fn main() {
// 十进制中用下划线分隔千位
let million = 1_000_000;
let billion = 1_000_000_000;
// 十六进制中按字节分隔
let color = 0xFF_88_00;
let mask = 0xFFFF_0000;
// 二进制中按 4 位或 8 位分隔
let byte = 0b1111_0000;
let word = 0b1010_1100_0011_1001;
// 下划线可以放在任何数字之间(但不能在开头或类型后缀前后)
let weird_but_valid = 1___000; // 合法,等于 1000
println!("{}, {}, 0x{:06X}, 0b{:08b}", million, billion, color, byte);
}类型后缀
类型后缀是直接附加在数字字面量后面的类型标记,它让你不需要额外写类型标注就能指定字面量的类型。
rust
fn main() {
// 有符号整数后缀
let a = 42i8; // i8 类型
let b = 42i16; // i16 类型
let c = 42i32; // i32 类型(和默认一样)
let d = 42i64; // i64 类型
let e = 42i128; // i128 类型
let f = 42isize; // isize 类型
// 无符号整数后缀
let g = 42u8; // u8 类型
let h = 42u16; // u16 类型
let i = 42u32; // u32 类型
let j = 42u64; // u64 类型
let k = 42u128; // u128 类型
let l = 42usize; // usize 类型
// 浮点数后缀
let m = 3.14f32; // f32 类型
let n = 3.14f64; // f64 类型
// 后缀可以和下划线分隔符一起用
let big = 1_000_000u64;
let hex = 0xFF_u8;
let bin = 0b1010_i32;
println!("i8: {}, u64: {}, f32: {}", a, big, m);
}类型后缀 vs 类型标注
两种方式效果完全一样,选哪种取决于可读性。
rust
fn main() {
// 类型标注方式
let a: u64 = 1000;
// 类型后缀方式
let b = 1000u64;
// 两者完全等价
assert_eq!(a, b);
// 类型后缀在某些场景下更简洁
// 比如直接传给函数时:
println!("{}", 255u8.count_ones()); // 调用 u8 的方法
// 在集合中指定元素类型
let nums = vec![1u8, 2, 3, 4, 5]; // 第一个元素指定了 u8,后面的自动推断
println!("{:?}", nums);
}| 方式 | 写法 | 适用场景 |
|---|---|---|
| 类型标注 | let x: u64 = 42; | 变量声明时,类型清晰 |
| 类型后缀 | let x = 42u64; | 字面量在表达式中,不方便加标注 |
| 不指定 | let x = 42; | 默认 i32 就够用时 |
基本示例
rust
fn main() {
// 场景一:定义颜色常量(十六进制 + u32)
const RED: u32 = 0xFF0000;
const GREEN: u32 = 0x00FF00;
const BLUE: u32 = 0x0000FF;
// 从颜色值中提取 RGB 分量
let color: u32 = 0xFF8833;
let r = (color >> 16) & 0xFF; // 右移 16 位取高 8 位
let g = (color >> 8) & 0xFF; // 右移 8 位取中间 8 位
let b = color & 0xFF; // 取低 8 位
println!("颜色 0x{:06X} -> R:{}, G:{}, B:{}", color, r, g, b);
// 场景二:文件权限(八进制)
let owner_read_write_exec = 0o700; // rwx------
let group_read_exec = 0o050; // ---r-x---
let other_read_exec = 0o005; // ------r-x
let full_permission = owner_read_write_exec | group_read_exec | other_read_exec;
println!("权限:0o{:03o}", full_permission); // 0o755
// 场景三:位标志(二进制)
const FLAG_READ: u8 = 0b0000_0001; // 第 0 位
const FLAG_WRITE: u8 = 0b0000_0010; // 第 1 位
const FLAG_EXEC: u8 = 0b0000_0100; // 第 2 位
let mut permissions: u8 = 0;
permissions |= FLAG_READ; // 设置读权限
permissions |= FLAG_WRITE; // 设置写权限
println!("权限位:0b{:08b}", permissions);
println!("有读权限:{}", permissions & FLAG_READ != 0); // true
println!("有写权限:{}", permissions & FLAG_WRITE != 0); // true
println!("有执行权限:{}", permissions & FLAG_EXEC != 0); // false
}常见问题
问题一:不指定类型时,字面量的默认类型是什么?
整数字面量默认是 i32,浮点数字面量默认是 f64。但如果上下文能推断出类型(比如赋值给一个已知类型的变量、传给一个参数类型确定的函数),编译器会使用推断出的类型。
rust
fn takes_u8(n: u8) {
println!("{}", n);
}
fn main() {
let x = 42; // 默认 i32
takes_u8(42); // 这里的 42 被推断为 u8
let y: u64 = 42; // 这里的 42 被推断为 u64
}问题二:字面量超出类型范围会怎样?
编译器会直接报错,不会允许一个超出范围的字面量通过编译。
rust
fn main() {
// let x: u8 = 256; // 编译错误:literal out of range for `u8`
// let y: i8 = 128; // 编译错误:literal out of range for `i8`
let z: u8 = 255; // 合法,u8 的最大值
}问题三:0 开头的数字会被当成八进制吗?
不会。Rust 不像 C 语言那样把 0 开头的数字当八进制。042 在 Rust 中就是十进制的 42。八进制必须用 0o 前缀。
问题四:字面量的下划线有位置限制吗?
下划线不能放在字面量的最开头、进制前缀之前、或类型后缀之后。也不能连续两个下划线之间没有数字。但在合法位置上可以随意放。
适用场景
- 十六进制:颜色值、内存地址、位掩码、加密哈希值
- 八进制:Unix 文件权限
- 二进制:位标志、硬件寄存器操作、协议字段
- 下划线分隔:大数字的千位分隔,二进制/十六进制的字节分隔
- 类型后缀:在表达式中快速指定字面量类型,避免额外的类型标注
注意事项
- Rust 中
042不是八进制,八进制必须用0o前缀 - 字面量超出目标类型范围时,编译器会直接报错,不会静默截断
- 下划线分隔符只影响可读性,不影响值
- 字节字面量
b'A'的类型固定是u8,不能用类型后缀改 - 在不明确的上下文中,整数字面量默认是
i32,如果需要其他类型必须标注 - 类型后缀和类型标注选一个就行,不要同时写(虽然同时写相同类型不会报错,但是多余的)
总结
Rust 的整数字面量支持十进制、十六进制(0x)、八进制(0o)、二进制(0b)四种进制写法,可以在数字中间用下划线分隔以提高可读性。类型后缀(如 42u64、0xFFi32)可以直接在字面量上指定类型,和类型标注效果一样。整数字面量默认类型是 i32,但编译器会根据上下文推断实际需要的类型。字面量超出类型范围会在编译期直接报错,这比 C 语言的静默截断安全得多。