类型布局保证
核心概念
类型布局(type layout)指的是一个类型在内存中的大小(size)、对齐(alignment)和字段偏移(field offset)。Rust 对不同类型提供了不同级别的布局保证。基本类型(如 u8、i32、f64)的大小和对齐是固定的,在所有平台上都一样。复合类型的布局则取决于使用的 repr 属性——默认 Rust 布局不提供任何保证,#[repr(C)] 提供与 C 一致的确定性布局。
理解类型布局保证对于 unsafe 编程至关重要:指针偏移计算、transmute 类型转换、内存分配和 FFI 交互都依赖于对布局的正确理解。错误的布局假设会导致未定义行为。
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 默认布局的特点:
// 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)
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>());
}空指针优化
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)
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>());
}基本示例
利用布局知识实现安全的结构体序列化和反序列化:
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 编程中必须正确理解布局保证,错误的布局假设会导致未定义行为。