enum 枚举定义 ​

核心概念 ​

枚举(Enum)用来定义一个类型,这个类型的值只能是预定义的几种变体(Variant)之一。枚举表达的是"或"的关系——一个值要么是变体 A,要么是变体 B,不能同时是两个。Rust 的枚举比 C 语言的枚举强大得多,每个变体可以携带不同类型和数量的数据。枚举和 match 配合使用时,编译器会强制检查是否处理了所有变体,避免遗漏。

rust
// 最基本的枚举:每个变体不携带数据
enum Direction {
    North,
    South,
    East,
    West,
}

fn describe(dir: &Direction) -> &str {
    match dir {
        Direction::North => "北",
        Direction::South => "南",
        Direction::East => "东",
        Direction::West => "西",
    }
}

fn main() {
    let dir = Direction::East;
    println!("方向: {}", describe(&dir));

    // 枚举值通过 Type::Variant 语法创建
    let dirs = vec![
        Direction::North,
        Direction::South,
        Direction::East,
        Direction::West,
    ];
    for d in &dirs {
        println!("  {}", describe(d));
    }
}

枚举定义的语法 ​

rust
// 简单枚举(无数据)
enum Season {
    Spring,
    Summer,
    Autumn,
    Winter,
}

// C 风格枚举:显式指定整数值
enum HttpStatus {
    Ok = 200,
    NotFound = 404,
    InternalError = 500,
}

// 不指定值时,从 0 开始自动递增
enum Color {
    Red,    // 0
    Green,  // 1
    Blue,   // 2
}

fn main() {
    // C 风格枚举可以用 as 转为整数
    let status = HttpStatus::NotFound;
    println!("状态码: {}", status as i32);  // 404

    println!("Red = {}", Color::Red as i32);    // 0
    println!("Green = {}", Color::Green as i32);  // 1

    // 枚举在 match 中使用
    let season = Season::Summer;
    let desc = match season {
        Season::Spring => "万物复苏",
        Season::Summer => "烈日炎炎",
        Season::Autumn => "秋高气爽",
        Season::Winter => "寒风凛冽",
    };
    println!("季节: {}", desc);
}

为枚举实现方法 ​

枚举和结构体一样可以有 impl 块。

rust
#[derive(Debug)]
enum Weekday {
    Monday,
    Tuesday,
    Wednesday,
    Thursday,
    Friday,
    Saturday,
    Sunday,
}

impl Weekday {
    // 关联函数
    fn from_number(n: u8) -> Option<Weekday> {
        match n {
            1 => Some(Weekday::Monday),
            2 => Some(Weekday::Tuesday),
            3 => Some(Weekday::Wednesday),
            4 => Some(Weekday::Thursday),
            5 => Some(Weekday::Friday),
            6 => Some(Weekday::Saturday),
            7 => Some(Weekday::Sunday),
            _ => None,
        }
    }

    // 方法
    fn is_weekend(&self) -> bool {
        matches!(self, Weekday::Saturday | Weekday::Sunday)
    }

    fn is_workday(&self) -> bool {
        !self.is_weekend()
    }

    fn name(&self) -> &str {
        match self {
            Weekday::Monday => "星期一",
            Weekday::Tuesday => "星期二",
            Weekday::Wednesday => "星期三",
            Weekday::Thursday => "星期四",
            Weekday::Friday => "星期五",
            Weekday::Saturday => "星期六",
            Weekday::Sunday => "星期日",
        }
    }

    fn next(&self) -> Weekday {
        match self {
            Weekday::Monday => Weekday::Tuesday,
            Weekday::Tuesday => Weekday::Wednesday,
            Weekday::Wednesday => Weekday::Thursday,
            Weekday::Thursday => Weekday::Friday,
            Weekday::Friday => Weekday::Saturday,
            Weekday::Saturday => Weekday::Sunday,
            Weekday::Sunday => Weekday::Monday,
        }
    }
}

fn main() {
    let today = Weekday::Wednesday;
    println!("今天: {}", today.name());
    println!("工作日: {}", today.is_workday());
    println!("明天: {}", today.next().name());

    // 从数字创建
    for n in 1..=7 {
        if let Some(day) = Weekday::from_number(n) {
            let kind = if day.is_weekend() { "休息" } else { "工作" };
            println!("  {} -> {} ({})", n, day.name(), kind);
        }
    }
}

枚举与 derive ​

rust
// 简单枚举可以 derive 很多 trait
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
enum Priority {
    Low,
    Medium,
    High,
    Critical,
}

impl Priority {
    fn level(&self) -> u8 {
        match self {
            Priority::Low => 1,
            Priority::Medium => 2,
            Priority::High => 3,
            Priority::Critical => 4,
        }
    }

    fn label(&self) -> &str {
        match self {
            Priority::Low => "低",
            Priority::Medium => "中",
            Priority::High => "高",
            Priority::Critical => "紧急",
        }
    }
}

fn main() {
    let p1 = Priority::High;
    let p2 = Priority::High;
    let p3 = Priority::Low;

    // PartialEq:可以比较
    println!("p1 == p2: {}", p1 == p2);  // true
    println!("p1 == p3: {}", p1 == p3);  // false

    // Copy:赋值不转移所有权
    let p4 = p1;
    println!("p1: {:?}, p4: {:?}", p1, p4);  // p1 仍可用

    // 使用在 HashMap 中(Hash + Eq)
    use std::collections::HashMap;
    let mut counts: HashMap<Priority, u32> = HashMap::new();
    let tasks = vec![Priority::High, Priority::Low, Priority::High, Priority::Medium];
    for task in tasks {
        *counts.entry(task).or_insert(0) += 1;
    }
    for (priority, count) in &counts {
        println!("{}: {} 个任务", priority.label(), count);
    }
}

枚举的内存布局 ​

rust
use std::mem;

// 枚举大小 = 判别值 + 最大变体的数据
enum Simple {
    A,  // 无数据
    B,  // 无数据
    C,  // 无数据
}

enum WithData {
    Empty,
    Small(u8),        // 1 字节
    Large(u64),       // 8 字节(最大变体)
}

fn main() {
    // 简单枚举只需要一个判别值
    println!("Simple 大小: {} 字节", mem::size_of::<Simple>());

    // 带数据的枚举:判别值 + 最大变体 + 对齐
    println!("WithData 大小: {} 字节", mem::size_of::<WithData>());

    // Option<&T> 的空指针优化:和裸指针大小相同
    println!("Option<&i32> 大小: {} 字节", mem::size_of::<Option<&i32>>());
    println!("&i32 大小: {} 字节", mem::size_of::<&i32>());
}

基本示例 ​

用枚举建模一个交通信号灯系统:

rust
#[derive(Debug, Clone, Copy, PartialEq)]
enum TrafficLight {
    Red,
    Yellow,
    Green,
}

impl TrafficLight {
    // 获取灯的持续时间(秒)
    fn duration(&self) -> u32 {
        match self {
            TrafficLight::Red => 60,
            TrafficLight::Yellow => 5,
            TrafficLight::Green => 45,
        }
    }

    // 获取下一个状态
    fn next(&self) -> TrafficLight {
        match self {
            TrafficLight::Red => TrafficLight::Green,
            TrafficLight::Yellow => TrafficLight::Red,
            TrafficLight::Green => TrafficLight::Yellow,
        }
    }

    // 是否可以通行
    fn can_go(&self) -> bool {
        *self == TrafficLight::Green
    }

    // 是否应该减速
    fn should_slow_down(&self) -> bool {
        *self == TrafficLight::Yellow
    }

    fn color_name(&self) -> &str {
        match self {
            TrafficLight::Red => "红灯",
            TrafficLight::Yellow => "黄灯",
            TrafficLight::Green => "绿灯",
        }
    }
}

#[derive(Debug)]
struct Intersection {
    name: String,
    main_road: TrafficLight,
    side_road: TrafficLight,
}

impl Intersection {
    fn new(name: &str) -> Self {
        Intersection {
            name: name.to_string(),
            main_road: TrafficLight::Green,
            side_road: TrafficLight::Red,
        }
    }

    fn advance(&mut self) {
        self.main_road = self.main_road.next();
        // 简化逻辑:主路变红时,侧路变绿
        if self.main_road == TrafficLight::Red {
            self.side_road = TrafficLight::Green;
        } else if self.main_road == TrafficLight::Green {
            self.side_road = TrafficLight::Red;
        } else {
            self.side_road = TrafficLight::Yellow;
        }
    }

    fn display(&self) {
        println!("[{}] 主路: {} ({}秒), 侧路: {} ({}秒)",
            self.name,
            self.main_road.color_name(),
            self.main_road.duration(),
            self.side_road.color_name(),
            self.side_road.duration(),
        );
    }
}

fn main() {
    let mut intersection = Intersection::new("中山路口");

    println!("=== 交通灯模拟 ===");
    for i in 0..6 {
        println!("\n第 {} 轮:", i + 1);
        intersection.display();

        // 给车辆建议
        if intersection.main_road.can_go() {
            println!("  主路车辆: 可以通行");
        } else if intersection.main_road.should_slow_down() {
            println!("  主路车辆: 减速准备停车");
        } else {
            println!("  主路车辆: 等待");
        }

        intersection.advance();
    }
}

常见问题 ​

问题一:枚举和常量组有什么区别?

特性枚举常量组
类型安全有独立类型没有类型约束
编译器检查match 穷尽检查无检查
可以有方法可以(impl 块)不可以
可以携带数据可以(下一节详细讲)不可以

问题二:枚举变体有数量限制吗?

语言本身没有硬性限制。但变体数量影响判别值的大小——2个变体只需要 1 位,256个变体需要 1 字节,超过 256 个需要 2 字节。实际项目中很少超过几十个变体。

问题三:如何遍历枚举的所有变体?

Rust 标准库没有内置枚举遍历。可以手动实现一个返回所有变体的函数,或者使用第三方 crate 如 strum 提供的 derive 宏来自动生成遍历功能。

问题四:枚举可以为空(没有变体)吗?

可以。空枚举 enum Never {} 没有任何变体,意味着这个类型不可能有值。它类似于 !(never type),用于表示不可能发生的情况。

适用场景 ​

  • 状态表示:交通灯、订单状态、连接状态等
  • 分类标签:优先级、类型、方向等分类场景
  • 有限选项:一周七天、四季、HTTP 方法等
  • C 风格常量:需要和整数值对应的情况

注意事项 ​

  • 枚举变体通过 Type::Variant 语法创建和匹配
  • match 必须覆盖所有变体(穷尽匹配)
  • 简单枚举可以 derive Debug、Clone、Copy、PartialEq、Eq、Hash 等
  • C 风格枚举可以用 as 转为整数
  • 枚举可以有 impl 块定义方法和关联函数
  • 枚举大小由最大变体决定
  • Option<&T> 享受空指针优化,大小和 &T 相同

总结 ​

枚举是 Rust 中定义"一个类型可以是几种形态之一"的方式。最基本的枚举不携带数据,每个变体就是一个独立的标签。枚举可以有 impl 块定义方法和关联函数,也可以 derive 各种常用 trait。C 风格枚举可以指定整数值并用 as 转换。match 和枚举配合使用时,编译器强制覆盖所有变体,避免遗漏任何情况。枚举是 Rust 类型系统中最具表现力的工具之一,广泛用于状态表示、分类、选项等场景。