单元结构体 ​

核心概念 ​

单元结构体(Unit Struct)是没有任何字段的结构体,定义时不需要花括号也不需要圆括号。它不占用任何内存空间(大小为零),但它是一个独立的类型。单元结构体的主要用途是作为标记类型——当你需要一个类型来实现某个 trait,但不需要存储任何数据时,单元结构体就是最合适的选择。

rust
// 定义单元结构体:没有字段
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 中有实际用途。编译器知道它们不占空间,会在编译时优化掉所有与存储相关的操作。

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,提供特定的行为。

rust
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);
}

作为泛型的类型参数 ​

rust
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 配合模拟集合 ​

rust
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!("访问过产品页");
    }
}

基本示例 ​

用单元结构体实现策略模式——不同的排序策略:

rust
// 排序方向
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 零成本抽象的体现。