整数字面量与类型后缀 ​

什么是整数字面量 ​

整数字面量就是你在代码中直接写的数字,比如 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 语言的静默截断安全得多。