类型布局保证 ​

核心概念 ​

类型布局(type layout)指的是一个类型在内存中的大小(size)、对齐(alignment)和字段偏移(field offset)。Rust 对不同类型提供了不同级别的布局保证。基本类型(如 u8、i32、f64)的大小和对齐是固定的,在所有平台上都一样。复合类型的布局则取决于使用的 repr 属性——默认 Rust 布局不提供任何保证,#[repr(C)] 提供与 C 一致的确定性布局。

理解类型布局保证对于 unsafe 编程至关重要:指针偏移计算、transmute 类型转换、内存分配和 FFI 交互都依赖于对布局的正确理解。错误的布局假设会导致未定义行为。

rust
fn main() {
    // 基本类型的布局是固定的
    println!("=== 基本类型布局 ===");
    println!("bool:  大小={}, 对齐={}", std::mem::size_of::<bool>(), std::mem::align_of::<bool>());
    println!("u8:    大小={}, 对齐={}", std::mem::size_of::<u8>(), std::mem::align_of::<u8>());
    println!("u16:   大小={}, 对齐={}", std::mem::size_of::<u16>(), std::mem::align_of::<u16>());
    println!("u32:   大小={}, 对齐={}", std::mem::size_of::<u32>(), std::mem::align_of::<u32>());
    println!("u64:   大小={}, 对齐={}", std::mem::size_of::<u64>(), std::mem::align_of::<u64>());
    println!("u128:  大小={}, 对齐={}", std::mem::size_of::<u128>(), std::mem::align_of::<u128>());
    println!("f32:   大小={}, 对齐={}", std::mem::size_of::<f32>(), std::mem::align_of::<f32>());
    println!("f64:   大小={}, 对齐={}", std::mem::size_of::<f64>(), std::mem::align_of::<f64>());
    println!("usize: 大小={}, 对齐={}", std::mem::size_of::<usize>(), std::mem::align_of::<usize>());

    // 指针和引用的大小等于 usize
    println!("\n=== 指针类型 ===");
    println!("*const u8:  大小={}", std::mem::size_of::<*const u8>());
    println!("&u8:        大小={}", std::mem::size_of::<&u8>());
    println!("&mut u8:    大小={}", std::mem::size_of::<&mut u8>());

    // 胖指针(包含额外元数据)
    println!("&[u8]:      大小={} (指针+长度)", std::mem::size_of::<&[u8]>());
    println!("&str:       大小={} (指针+长度)", std::mem::size_of::<&str>());
    println!("&dyn Send:  大小={} (指针+vtable)", std::mem::size_of::<&dyn Send>());
}

Rust 默认布局 vs repr(C) ​

rust
// Rust 默认布局的特点:
// 1. 字段顺序不确定(编译器可能重排)
// 2. 填充不确定
// 3. 大小可能随编译器版本变化
// 4. 唯一保证:大小是对齐的整数倍

// 不要对默认布局做任何假设
struct DefaultLayout {
    a: u8,
    b: u32,
    c: u16,
    d: u8,
}

#[repr(C)]
struct CLayout {
    a: u8,     // 偏移 0
    // 3 字节填充
    b: u32,    // 偏移 4
    c: u16,    // 偏移 8
    d: u8,     // 偏移 10
    // 1 字节填充
}
// 总大小 12,对齐 4

fn main() {
    println!("=== 默认 vs repr(C) ===");
    println!("DefaultLayout: 大小={}, 对齐={}",
        std::mem::size_of::<DefaultLayout>(),
        std::mem::align_of::<DefaultLayout>());
    println!("CLayout: 大小={}, 对齐={}",
        std::mem::size_of::<CLayout>(),
        std::mem::align_of::<CLayout>());

    // 默认布局可能更小(编译器优化了字段顺序)
    // 但不能依赖这个结果

    // repr(C) 的字段偏移是确定的
    let c = CLayout { a: 1, b: 2, c: 3, d: 4 };
    let base = &c as *const CLayout as usize;
    println!("\nrepr(C) 字段偏移:");
    println!("  a: {}", &c.a as *const u8 as usize - base);
    println!("  b: {}", &c.b as *const u32 as usize - base);
    println!("  c: {}", &c.c as *const u16 as usize - base);
    println!("  d: {}", &c.d as *const u8 as usize - base);
}
布局属性字段顺序填充大小稳定适用场景
默认编译器决定编译器决定不保证纯 Rust 代码
repr(C)声明顺序C 规则确定FFI、二进制格式
repr(transparent)与内部类型相同无确定newtype
repr(packed)声明顺序无填充确定紧凑协议

零大小类型(ZST) ​

rust
use std::marker::PhantomData;

// 零大小类型:不占用任何内存
struct Empty;                          // 空结构体
struct UnitLike;                       // 类单元结构体
struct Marker<T>(PhantomData<T>);      // PhantomData

fn main() {
    println!("=== 零大小类型 ===");
    println!("():          大小={}", std::mem::size_of::<()>());
    println!("Empty:       大小={}", std::mem::size_of::<Empty>());
    println!("UnitLike:    大小={}", std::mem::size_of::<UnitLike>());
    println!("PhantomData: 大小={}", std::mem::size_of::<PhantomData<String>>());

    // ZST 的特殊性质:
    // 1. 不占用内存
    // 2. 对齐为 1
    // 3. 可以创建无限多个(不消耗内存)
    // 4. Vec<ZST> 不分配堆内存

    let v: Vec<()> = vec![(); 1000];
    println!("\nVec<()> 长度 1000:");
    println!("  len={}, capacity={}", v.len(), v.capacity());
    // 不占用堆内存

    // ZST 的用途
    // - 类型标记(PhantomData)
    // - 集合中只关心数量(HashSet 内部用 HashMap<K, ()>)
    // - 类型状态模式

    println!("\n=== 对齐 ===");
    println!("():          对齐={}", std::mem::align_of::<()>());
    println!("Empty:       对齐={}", std::mem::align_of::<Empty>());
}

空指针优化 ​

rust
use std::num::NonZeroU32;
use std::ptr::NonNull;

fn main() {
    // Rust 对某些类型的 Option 做了空指针优化(niche optimization)
    // Option<T> 的大小可能等于 T 的大小

    println!("=== 空指针优化 ===");

    // 引用保证非空,None 用 null 表示
    println!("&u32:             {} 字节", std::mem::size_of::<&u32>());
    println!("Option<&u32>:     {} 字节", std::mem::size_of::<Option<&u32>>());
    // 大小相同!

    // NonNull 同理
    println!("NonNull<u32>:         {} 字节", std::mem::size_of::<NonNull<u32>>());
    println!("Option<NonNull<u32>>: {} 字节", std::mem::size_of::<Option<NonNull<u32>>>());

    // NonZeroU32:0 被用来表示 None
    println!("NonZeroU32:             {} 字节", std::mem::size_of::<NonZeroU32>());
    println!("Option<NonZeroU32>:     {} 字节", std::mem::size_of::<Option<NonZeroU32>>());

    // 函数指针
    println!("fn():             {} 字节", std::mem::size_of::<fn()>());
    println!("Option<fn()>:     {} 字节", std::mem::size_of::<Option<fn()>>());

    // Box 也是非空的
    println!("Box<u32>:             {} 字节", std::mem::size_of::<Box<u32>>());
    println!("Option<Box<u32>>:     {} 字节", std::mem::size_of::<Option<Box<u32>>>());

    // 普通整数没有空指针优化
    println!("\n=== 无优化 ===");
    println!("u32:             {} 字节", std::mem::size_of::<u32>());
    println!("Option<u32>:     {} 字节", std::mem::size_of::<Option<u32>>());
    // Option<u32> 比 u32 大(需要额外的判别位)

    println!("bool:            {} 字节", std::mem::size_of::<bool>());
    println!("Option<bool>:    {} 字节", std::mem::size_of::<Option<bool>>());
    // bool 只用 0 和 1,Option 用 2 表示 None(利用了 niche)
}

动态大小类型(DST) ​

rust
fn main() {
    // 动态大小类型:大小在编译时未知
    // 只能通过引用或指针使用

    // === [T]:切片 ===
    // 大小不确定(取决于元素数量)
    // &[T] 是胖指针:(指针, 长度)
    let arr = [1, 2, 3, 4, 5];
    let slice: &[i32] = &arr;
    println!("=== 切片 ===");
    println!("&[i32] 大小: {} (指针+长度)", std::mem::size_of::<&[i32]>());
    println!("切片长度: {}", slice.len());

    // === str:字符串切片 ===
    let s: &str = "hello";
    println!("\n=== str ===");
    println!("&str 大小: {} (指针+长度)", std::mem::size_of::<&str>());
    println!("字符串长度: {}", s.len());

    // === dyn Trait:trait 对象 ===
    let boxed: Box<dyn std::fmt::Debug> = Box::new(42);
    println!("\n=== dyn Trait ===");
    println!("&dyn Debug 大小: {} (指针+vtable)", std::mem::size_of::<&dyn std::fmt::Debug>());
    println!("Box<dyn Debug> 大小: {} (指针+vtable)", std::mem::size_of::<Box<dyn std::fmt::Debug>>());

    // 普通引用(瘦指针)vs 胖指针
    println!("\n=== 瘦 vs 胖 ===");
    println!("&i32 (瘦):       {} 字节", std::mem::size_of::<&i32>());
    println!("&[i32] (胖):     {} 字节", std::mem::size_of::<&[i32]>());
    println!("&dyn Debug (胖): {} 字节", std::mem::size_of::<&dyn std::fmt::Debug>());
}

基本示例 ​

利用布局知识实现安全的结构体序列化和反序列化:

rust
use std::mem;

/// 布局检查器:验证类型布局信息
fn print_layout<T>(name: &str) {
    println!("  {}: 大小={}, 对齐={}", name, mem::size_of::<T>(), mem::align_of::<T>());
}

/// 安全的结构体转字节切片(只适用于 Copy + repr(C) 类型)
fn as_bytes<T: Copy>(value: &T) -> &[u8] {
    // SAFETY: 任何 Copy 类型都可以安全地视为字节序列
    unsafe {
        std::slice::from_raw_parts(
            value as *const T as *const u8,
            mem::size_of::<T>(),
        )
    }
}

/// 从字节切片还原结构体
fn from_bytes<T: Copy>(bytes: &[u8]) -> Option<T> {
    if bytes.len() < mem::size_of::<T>() {
        return None;
    }

    let ptr = bytes.as_ptr();

    // 检查对齐
    if (ptr as usize) % mem::align_of::<T>() != 0 {
        // 未对齐,使用 read_unaligned
        // SAFETY: 长度已检查
        return Some(unsafe { (ptr as *const T).read_unaligned() });
    }

    // SAFETY: 长度和对齐已检查
    Some(unsafe { (ptr as *const T).read() })
}

// 网络数据包头部
#[repr(C)]
#[derive(Debug, Clone, Copy)]
struct PacketHeader {
    version: u8,
    packet_type: u8,
    length: u16,
    sequence: u32,
    checksum: u32,
}

impl PacketHeader {
    fn new(packet_type: u8, length: u16, sequence: u32) -> Self {
        let mut header = PacketHeader {
            version: 1,
            packet_type,
            length,
            sequence,
            checksum: 0,
        };
        header.checksum = header.calculate_checksum();
        header
    }

    fn calculate_checksum(&self) -> u32 {
        let bytes = as_bytes(self);
        let mut sum: u32 = 0;
        // 跳过 checksum 字段本身(最后 4 字节)
        for &b in &bytes[..bytes.len() - 4] {
            sum = sum.wrapping_add(b as u32);
        }
        sum
    }

    fn verify_checksum(&self) -> bool {
        self.checksum == self.calculate_checksum()
    }

    fn serialize(&self) -> Vec<u8> {
        as_bytes(self).to_vec()
    }

    fn deserialize(bytes: &[u8]) -> Option<Self> {
        let header: Self = from_bytes(bytes)?;
        if header.version != 1 {
            return None;
        }
        if !header.verify_checksum() {
            return None;
        }
        Some(header)
    }
}

// 传感器数据记录
#[repr(C)]
#[derive(Debug, Clone, Copy)]
struct SensorRecord {
    timestamp: u64,
    sensor_id: u16,
    flags: u16,
    temperature: f32,
    humidity: f32,
    pressure: f32,
}

fn main() {
    // 布局信息
    println!("=== 类型布局 ===");
    print_layout::<PacketHeader>("PacketHeader");
    print_layout::<SensorRecord>("SensorRecord");
    print_layout::<u8>("u8");
    print_layout::<u16>("u16");
    print_layout::<u32>("u32");
    print_layout::<u64>("u64");
    print_layout::<f32>("f32");

    // 序列化数据包
    println!("\n=== 序列化 ===");
    let header = PacketHeader::new(1, 256, 42);
    println!("原始: {:?}", header);

    let bytes = header.serialize();
    println!("字节({} 个): {:02X?}", bytes.len(), bytes);

    // 反序列化
    println!("\n=== 反序列化 ===");
    match PacketHeader::deserialize(&bytes) {
        Some(h) => {
            println!("还原: {:?}", h);
            println!("校验: {}", h.verify_checksum());
        }
        None => println!("反序列化失败"),
    }

    // 篡改检测
    let mut bad_bytes = bytes.clone();
    bad_bytes[2] = 0xFF;  // 篡改 length 字段
    match PacketHeader::deserialize(&bad_bytes) {
        Some(_) => println!("意外通过"),
        None => println!("篡改检测: 校验失败(预期)"),
    }

    // 传感器数据
    println!("\n=== 传感器数据 ===");
    let record = SensorRecord {
        timestamp: 1700000000,
        sensor_id: 42,
        flags: 0x0001,
        temperature: 25.5,
        humidity: 60.0,
        pressure: 1013.25,
    };

    let bytes = as_bytes(&record);
    println!("序列化: {} 字节", bytes.len());

    let restored: SensorRecord = from_bytes(bytes).unwrap();
    println!("还原: {:?}", restored);

    // 验证一致性
    assert_eq!(record.timestamp, restored.timestamp);
    assert_eq!(record.sensor_id, restored.sensor_id);
    assert_eq!(record.temperature, restored.temperature);
    println!("数据一致性: 通过");
}

常见问题 ​

问题一:为什么 Rust 不保证默认布局?

为了给编译器最大的优化自由。编译器可以重排字段减少填充、将相同对齐的字段放在一起提高缓存效率。如果保证布局,这些优化就无法进行。

问题二:size_of 和 align_of 在编译时能确定吗?

对于 Sized 类型,是的。std::mem::size_of::<T>() 和 std::mem::align_of::<T>() 都是编译时常量函数(const fn)。动态大小类型(DST)的大小只能在运行时确定。

问题三:为什么 Option<&T> 和 &T 大小相同?

因为引用保证非空,编译器用 null(全零)表示 None。这叫空指针优化(niche optimization)。类似地,NonZeroU32、NonNull<T> 等类型的 Option 也不需要额外空间。

问题四:布局保证在跨平台时会变吗?

基本类型在所有平台上大小一致(u32 总是 4 字节)。但 usize/isize 和指针大小取决于目标平台(32位 vs 64位)。c_int、c_long 等 FFI 类型也可能因平台而异。

适用场景 ​

  • FFI:确保结构体布局与 C 一致
  • 序列化:将结构体转为字节流
  • 内存映射:将文件或设备内存映射为结构体
  • unsafe 编程:指针偏移和类型转换

注意事项 ​

  • 不要对默认 Rust 布局做任何假设
  • FFI 类型必须用 #[repr(C)]
  • 基本类型大小固定,usize/指针大小平台相关
  • ZST 大小为 0,不占用内存
  • DST 只能通过引用或指针使用
  • 空指针优化使 Option<&T> 与 &T 大小相同
  • size_of 返回的大小包括尾部填充

总结 ​

Rust 的类型布局保证分层次:基本类型(u8、i32、f64 等)的大小和对齐在所有平台上固定;#[repr(C)] 类型的布局与 C 一致且确定;默认 Rust 布局不提供任何保证,编译器可以自由优化。特殊类型包括零大小类型(ZST,大小为 0)和动态大小类型(DST,编译时大小未知)。Rust 的空指针优化使得 Option<&T>、Option<NonNull<T>> 等与内部类型大小相同。std::mem::size_of 和 std::mem::align_of 用于查询类型布局信息。unsafe 编程中必须正确理解布局保证,错误的布局假设会导致未定义行为。