单元结构体
核心概念
单元结构体(Unit Struct)是没有任何字段的结构体,定义时不需要花括号也不需要圆括号。它不占用任何内存空间(大小为零),但它是一个独立的类型。单元结构体的主要用途是作为标记类型——当你需要一个类型来实现某个 trait,但不需要存储任何数据时,单元结构体就是最合适的选择。
// 定义单元结构体:没有字段
struct Marker;
struct Empty;
fn main() {
// 创建实例:不需要花括号或圆括号
let m = Marker;
let e = Empty;
// 大小为零
println!("Marker 大小: {} 字节", std::mem::size_of::<Marker>());
println!("Empty 大小: {} 字节", std::mem::size_of::<Empty>());
// 但它们是不同的类型
// let wrong: Marker = e; // 编译错误:类型不匹配
}为什么需要零大小的类型
零大小类型(Zero-Sized Type,简称 ZST)在 Rust 中有实际用途。编译器知道它们不占空间,会在编译时优化掉所有与存储相关的操作。
struct AlwaysTrue;
struct AlwaysFalse;
// 用不同的类型表示不同的行为
trait Predicate {
fn test(&self, value: i32) -> bool;
}
impl Predicate for AlwaysTrue {
fn test(&self, _value: i32) -> bool {
true
}
}
impl Predicate for AlwaysFalse {
fn test(&self, _value: i32) -> bool {
false
}
}
fn filter_values<P: Predicate>(values: &[i32], predicate: &P) -> Vec<i32> {
values.iter()
.filter(|&&v| predicate.test(v))
.copied()
.collect()
}
fn main() {
let nums = vec![1, 2, 3, 4, 5];
let all = filter_values(&nums, &AlwaysTrue);
println!("全部: {:?}", all);
let none = filter_values(&nums, &AlwaysFalse);
println!("无: {:?}", none);
// AlwaysTrue 和 AlwaysFalse 不占内存
// 编译器可以完全内联 predicate.test() 的调用
}作为 trait 实现的载体
单元结构体最常见的用途是实现 trait,提供特定的行为。
use std::fmt;
// 定义不同的格式化策略
struct JsonFormatter;
struct TextFormatter;
struct CsvFormatter;
trait Formatter {
fn format(&self, key: &str, value: &str) -> String;
fn name(&self) -> &str;
}
impl Formatter for JsonFormatter {
fn format(&self, key: &str, value: &str) -> String {
format!(" \"{}\": \"{}\"", key, value)
}
fn name(&self) -> &str { "JSON" }
}
impl Formatter for TextFormatter {
fn format(&self, key: &str, value: &str) -> String {
format!("{} = {}", key, value)
}
fn name(&self) -> &str { "文本" }
}
impl Formatter for CsvFormatter {
fn format(&self, key: &str, value: &str) -> String {
format!("{},{}", key, value)
}
fn name(&self) -> &str { "CSV" }
}
fn output_data<F: Formatter>(formatter: &F, data: &[(&str, &str)]) {
println!("--- {} 格式 ---", formatter.name());
for (key, value) in data {
println!("{}", formatter.format(key, value));
}
}
fn main() {
let data = vec![
("name", "张三"),
("age", "28"),
("city", "北京"),
];
output_data(&JsonFormatter, &data);
println!();
output_data(&TextFormatter, &data);
println!();
output_data(&CsvFormatter, &data);
}作为泛型的类型参数
use std::marker::PhantomData;
// 用单元结构体表示状态
struct Locked;
struct Unlocked;
// 泛型结构体用类型参数表示状态
struct Door<State> {
name: String,
_state: PhantomData<State>, // 不占空间的类型标记
}
impl Door<Locked> {
fn new(name: &str) -> Self {
Door {
name: name.to_string(),
_state: PhantomData,
}
}
// 只有锁定状态的门可以解锁
fn unlock(self) -> Door<Unlocked> {
println!("{} 已解锁", self.name);
Door {
name: self.name,
_state: PhantomData,
}
}
}
impl Door<Unlocked> {
// 只有解锁状态的门可以打开
fn open(&self) {
println!("{} 已打开", self.name);
}
// 只有解锁状态的门可以锁定
fn lock(self) -> Door<Locked> {
println!("{} 已锁定", self.name);
Door {
name: self.name,
_state: PhantomData,
}
}
}
fn main() {
let door = Door::<Locked>::new("前门");
// door.open(); // 编译错误:锁着的门不能打开
let door = door.unlock();
door.open(); // 合法:门已解锁
let door = door.lock();
// door.open(); // 编译错误:又锁上了
// Locked 和 Unlocked 是零大小类型,不占内存
println!("Door<Locked> 大小: {}", std::mem::size_of::<Door<Locked>>());
println!("Door<Unlocked> 大小: {}", std::mem::size_of::<Door<Unlocked>>());
// 两者大小相同,因为 PhantomData<T> 也是零大小
}与 HashMap 配合模拟集合
use std::collections::HashMap;
// 标准库中的 HashSet 内部就是用 HashMap<K, ()> 实现的
// 这里用单元类型 () 演示类似思路
fn main() {
// 用 HashMap<String, ()> 模拟一个集合
let mut visited: HashMap<String, ()> = HashMap::new();
let pages = vec!["首页", "关于", "首页", "产品", "关于", "首页"];
for page in &pages {
visited.insert(page.to_string(), ());
}
println!("访问过的页面:");
for page in visited.keys() {
println!(" {}", page);
}
println!("共 {} 个不同页面", visited.len());
// 检查是否访问过
if visited.contains_key("产品") {
println!("访问过产品页");
}
}基本示例
用单元结构体实现策略模式——不同的排序策略:
// 排序方向
struct Ascending;
struct Descending;
// 排序策略 trait
trait SortOrder {
fn compare(&self, a: &i32, b: &i32) -> std::cmp::Ordering;
fn name(&self) -> &str;
}
impl SortOrder for Ascending {
fn compare(&self, a: &i32, b: &i32) -> std::cmp::Ordering {
a.cmp(b)
}
fn name(&self) -> &str { "升序" }
}
impl SortOrder for Descending {
fn compare(&self, a: &i32, b: &i32) -> std::cmp::Ordering {
b.cmp(a)
}
fn name(&self) -> &str { "降序" }
}
// 通用排序函数
fn sorted_by<S: SortOrder>(data: &[i32], order: &S) -> Vec<i32> {
let mut result = data.to_vec();
result.sort_by(|a, b| order.compare(a, b));
result
}
// 验证策略
struct NonEmpty;
struct Positive;
trait Validator {
fn validate(&self, data: &[i32]) -> Result<(), String>;
fn name(&self) -> &str;
}
impl Validator for NonEmpty {
fn validate(&self, data: &[i32]) -> Result<(), String> {
if data.is_empty() {
Err(String::from("数据不能为空"))
} else {
Ok(())
}
}
fn name(&self) -> &str { "非空检查" }
}
impl Validator for Positive {
fn validate(&self, data: &[i32]) -> Result<(), String> {
if data.iter().all(|&x| x > 0) {
Ok(())
} else {
Err(String::from("所有值必须为正数"))
}
}
fn name(&self) -> &str { "正数检查" }
}
fn process_data<S: SortOrder, V: Validator>(
data: &[i32],
order: &S,
validator: &V,
) {
println!("\n--- 处理数据 ---");
println!("验证器: {}", validator.name());
match validator.validate(data) {
Ok(()) => {
let sorted = sorted_by(data, order);
println!("排序方式: {}", order.name());
println!("结果: {:?}", sorted);
}
Err(msg) => {
println!("验证失败: {}", msg);
}
}
}
fn main() {
let data = vec![5, 2, 8, 1, 9, 3];
process_data(&data, &Ascending, &NonEmpty);
process_data(&data, &Descending, &NonEmpty);
let positive_data = vec![3, 7, 1, 5];
process_data(&positive_data, &Ascending, &Positive);
let mixed_data = vec![3, -1, 5];
process_data(&mixed_data, &Ascending, &Positive);
let empty: Vec<i32> = vec![];
process_data(&empty, &Ascending, &NonEmpty);
// 所有策略类型都是零大小,不占内存
println!("\nAscending 大小: {}", std::mem::size_of::<Ascending>());
println!("NonEmpty 大小: {}", std::mem::size_of::<NonEmpty>());
}常见问题
问题一:单元结构体和空元组 () 有什么区别?
| 特性 | 单元结构体 struct Foo; | 空元组 () |
|---|---|---|
| 类型 | 独立的命名类型 | 内置的单元类型 |
| 可以实现 trait | 可以 | 不能(外部 trait) |
| 语义 | 有名字,表达意图 | 无名,表示"无值" |
| 用途 | 策略、标记、类型状态 | 函数无返回值 |
问题二:单元结构体真的不占内存吗?
是的。std::mem::size_of::<UnitStruct>() 返回 0。编译器在优化时会完全消除零大小类型的存储和传递开销。Vec<UnitStruct> 只跟踪长度,不分配元素空间。
问题三:单元结构体可以 derive 吗?
可以。#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default)] 都支持。
问题四:PhantomData 是什么?
PhantomData<T> 是标准库提供的零大小类型,用来告诉编译器"这个结构体在逻辑上和类型 T 相关",但不实际存储 T 的数据。常用于泛型编程中的类型标记。
适用场景
- 策略模式:不同的策略用不同的单元结构体表示
- 类型状态模式:用泛型参数中的单元结构体表示状态
- 标记类型:只需要类型区分不需要数据的场景
- trait 实现载体:需要实现 trait 但不需要存储数据
注意事项
- 单元结构体大小为零,不占内存
- 单元结构体是独立的类型,不同的单元结构体互不兼容
- 常和 trait、泛型、PhantomData 配合使用
- 编译器会优化掉零大小类型的存储和传递开销
- 单元结构体可以使用 derive 宏
- 定义语法是
struct Name;(分号结尾,没有花括号或圆括号)
总结
单元结构体是没有任何字段的结构体,大小为零但作为独立类型存在。它的核心价值在于类型层面的区分——当你需要一个类型来实现 trait、作为泛型参数、或表示某种状态,但不需要存储任何数据时,单元结构体就是最佳选择。常见用途包括策略模式、类型状态模式、标记类型等。编译器会完全优化掉零大小类型的运行时开销,这是 Rust 零成本抽象的体现。