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 类型系统中最具表现力的工具之一,广泛用于状态表示、分类、选项等场景。