枚举变体与数据 ​

核心概念 ​

Rust 枚举最强大的特性是每个变体可以携带不同类型和数量的数据。这让枚举成为一个类型安全的标记联合体(Tagged Union)——同一个枚举类型下的不同变体,可以各自持有完全不同结构的数据。变体携带数据有三种形式:无数据变体、元组变体、命名字段变体,它们可以在同一个枚举中自由混合使用。

rust
#[derive(Debug)]
enum Message {
    // 无数据变体:只是一个标记
    Quit,

    // 元组变体:类似元组结构体
    Echo(String),

    // 多字段元组变体
    Move(i32, i32),

    // 命名字段变体:类似命名结构体
    ChangeColor { r: u8, g: u8, b: u8 },
}

fn handle(msg: &Message) {
    match msg {
        Message::Quit => println!("退出"),
        Message::Echo(text) => println!("回显: {}", text),
        Message::Move(x, y) => println!("移动到 ({}, {})", x, y),
        Message::ChangeColor { r, g, b } => {
            println!("颜色: ({}, {}, {})", r, g, b);
        }
    }
}

fn main() {
    let messages = vec![
        Message::Echo(String::from("hello")),
        Message::Move(10, 20),
        Message::ChangeColor { r: 255, g: 128, b: 0 },
        Message::Quit,
    ];

    for msg in &messages {
        handle(msg);
    }
}

三种变体形式的对比 ​

变体形式语法类似于适用场景
无数据Quit单元结构体信号、标记、状态
元组Echo(String)元组结构体数据少、含义明确
命名字段ChangeColor { r: u8, g: u8, b: u8 }命名结构体数据多、需要字段名
rust
#[derive(Debug)]
enum Shape {
    // 无数据:代表一个点
    Point,

    // 单字段元组变体:圆(半径)
    Circle(f64),

    // 多字段元组变体:矩形(宽、高)
    Rectangle(f64, f64),

    // 命名字段变体:三角形(三个顶点坐标)
    Triangle {
        x1: f64, y1: f64,
        x2: f64, y2: f64,
        x3: f64, y3: f64,
    },
}

impl Shape {
    fn area(&self) -> f64 {
        match self {
            Shape::Point => 0.0,
            Shape::Circle(r) => std::f64::consts::PI * r * r,
            Shape::Rectangle(w, h) => w * h,
            Shape::Triangle { x1, y1, x2, y2, x3, y3 } => {
                // 向量叉积法计算面积
                ((x1 * (y2 - y3) + x2 * (y3 - y1) + x3 * (y1 - y2)) / 2.0).abs()
            }
        }
    }

    fn name(&self) -> &str {
        match self {
            Shape::Point => "点",
            Shape::Circle(_) => "圆",
            Shape::Rectangle(_, _) => "矩形",
            Shape::Triangle { .. } => "三角形",
        }
    }
}

fn main() {
    let shapes = vec![
        Shape::Point,
        Shape::Circle(5.0),
        Shape::Rectangle(4.0, 6.0),
        Shape::Triangle {
            x1: 0.0, y1: 0.0,
            x2: 4.0, y2: 0.0,
            x3: 0.0, y3: 3.0,
        },
    ];

    for shape in &shapes {
        println!("{}: 面积 = {:.2}", shape.name(), shape.area());
    }
}

提取变体数据 ​

match 提取 ​

rust
#[derive(Debug)]
enum Config {
    Text(String),
    Number(i64),
    Float(f64),
    Boolean(bool),
    List(Vec<String>),
}

fn describe(config: &Config) -> String {
    match config {
        Config::Text(s) => format!("文本: \"{}\"", s),
        Config::Number(n) => format!("整数: {}", n),
        Config::Float(f) => format!("浮点: {:.2}", f),
        Config::Boolean(b) => format!("布尔: {}", b),
        Config::List(items) => format!("列表: {:?}", items),
    }
}

fn main() {
    let configs = vec![
        Config::Text(String::from("hello")),
        Config::Number(42),
        Config::Float(3.14),
        Config::Boolean(true),
        Config::List(vec![String::from("a"), String::from("b")]),
    ];

    for cfg in &configs {
        println!("{}", describe(cfg));
    }
}

if let 提取 ​

rust
#[derive(Debug)]
enum Event {
    Click { x: i32, y: i32 },
    KeyPress(char),
    Scroll(f64),
    Close,
}

fn main() {
    let event = Event::Click { x: 100, y: 200 };

    // 只关心 Click 事件
    if let Event::Click { x, y } = &event {
        println!("点击位置: ({}, {})", x, y);
    }

    let event2 = Event::KeyPress('a');

    // 只关心 KeyPress
    if let Event::KeyPress(ch) = &event2 {
        println!("按键: '{}'", ch);
    }

    // if let ... else
    if let Event::Close = &event {
        println!("关闭");
    } else {
        println!("不是关闭事件");
    }
}

用 .. 忽略部分字段 ​

rust
#[derive(Debug)]
enum Packet {
    Tcp {
        source: u16,
        dest: u16,
        payload: Vec<u8>,
        flags: u8,
    },
    Udp {
        source: u16,
        dest: u16,
        payload: Vec<u8>,
    },
    Icmp {
        msg_type: u8,
        code: u8,
    },
}

impl Packet {
    // 只关心目标端口
    fn dest_port(&self) -> Option<u16> {
        match self {
            Packet::Tcp { dest, .. } => Some(*dest),  // .. 忽略其余字段
            Packet::Udp { dest, .. } => Some(*dest),
            Packet::Icmp { .. } => None,
        }
    }

    // 只关心是否有 payload
    fn has_payload(&self) -> bool {
        match self {
            Packet::Tcp { payload, .. } => !payload.is_empty(),
            Packet::Udp { payload, .. } => !payload.is_empty(),
            Packet::Icmp { .. } => false,
        }
    }

    fn protocol(&self) -> &str {
        match self {
            Packet::Tcp { .. } => "TCP",
            Packet::Udp { .. } => "UDP",
            Packet::Icmp { .. } => "ICMP",
        }
    }
}

fn main() {
    let packets = vec![
        Packet::Tcp {
            source: 54321,
            dest: 80,
            payload: vec![0x48, 0x54],
            flags: 0x18,
        },
        Packet::Udp {
            source: 12345,
            dest: 53,
            payload: vec![],
        },
        Packet::Icmp {
            msg_type: 8,
            code: 0,
        },
    ];

    for pkt in &packets {
        println!("{}: 目标端口={:?}, 有负载={}",
            pkt.protocol(), pkt.dest_port(), pkt.has_payload());
    }
}

变体内嵌复杂类型 ​

变体的数据可以是任意类型,包括其他枚举、结构体、Vec、HashMap 等。

rust
use std::collections::HashMap;

#[derive(Debug, Clone)]
struct Address {
    city: String,
    street: String,
}

#[derive(Debug)]
enum ContactInfo {
    // 嵌套结构体
    Physical(Address),

    // 嵌套多种基础类型
    Email(String),

    // 嵌套 Vec
    PhoneNumbers(Vec<String>),

    // 嵌套 HashMap
    Social(HashMap<String, String>),

    // 无联系方式
    None,
}

impl ContactInfo {
    fn summary(&self) -> String {
        match self {
            ContactInfo::Physical(addr) => {
                format!("地址: {}, {}", addr.city, addr.street)
            }
            ContactInfo::Email(email) => {
                format!("邮箱: {}", email)
            }
            ContactInfo::PhoneNumbers(phones) => {
                format!("电话: {}", phones.join(", "))
            }
            ContactInfo::Social(accounts) => {
                let list: Vec<String> = accounts.iter()
                    .map(|(k, v)| format!("{}:{}", k, v))
                    .collect();
                format!("社交: {}", list.join(", "))
            }
            ContactInfo::None => String::from("无联系方式"),
        }
    }
}

fn main() {
    let contacts = vec![
        ContactInfo::Physical(Address {
            city: String::from("北京"),
            street: String::from("长安街1号"),
        }),
        ContactInfo::Email(String::from("user@example.com")),
        ContactInfo::PhoneNumbers(vec![
            String::from("13800138000"),
            String::from("01012345678"),
        ]),
        ContactInfo::Social({
            let mut m = HashMap::new();
            m.insert(String::from("微博"), String::from("@rust_dev"));
            m.insert(String::from("GitHub"), String::from("rustacean"));
            m
        }),
        ContactInfo::None,
    ];

    for contact in &contacts {
        println!("{}", contact.summary());
    }
}

枚举的内存大小优化 ​

rust
use std::mem;

// 一个变体特别大时,整个枚举都变大
enum Unoptimized {
    Small(u8),                    // 1 字节
    Large([u8; 1024]),            // 1024 字节(所有变体都占这么多空间)
}

// 用 Box 把大数据放到堆上
enum Optimized {
    Small(u8),                    // 1 字节
    Large(Box<[u8; 1024]>),       // 8 字节(指针大小)
}

fn main() {
    println!("Unoptimized: {} 字节", mem::size_of::<Unoptimized>());
    println!("Optimized: {} 字节", mem::size_of::<Optimized>());

    // 差距很大:Box 版本只占指针大小 + 判别值
}

基本示例 ​

用枚举变体数据建模一个 JSON 解析器的值类型:

rust
use std::collections::HashMap;

#[derive(Debug, Clone)]
enum JsonValue {
    Null,
    Bool(bool),
    Number(f64),
    Str(String),
    Array(Vec<JsonValue>),
    Object(HashMap<String, JsonValue>),
}

impl JsonValue {
    fn type_name(&self) -> &str {
        match self {
            JsonValue::Null => "null",
            JsonValue::Bool(_) => "boolean",
            JsonValue::Number(_) => "number",
            JsonValue::Str(_) => "string",
            JsonValue::Array(_) => "array",
            JsonValue::Object(_) => "object",
        }
    }

    fn as_str(&self) -> Option<&str> {
        if let JsonValue::Str(s) = self { Some(s) } else { None }
    }

    fn as_number(&self) -> Option<f64> {
        if let JsonValue::Number(n) = self { Some(*n) } else { None }
    }

    fn as_bool(&self) -> Option<bool> {
        if let JsonValue::Bool(b) = self { Some(*b) } else { None }
    }

    fn is_null(&self) -> bool {
        matches!(self, JsonValue::Null)
    }

    // 获取 Object 中的字段
    fn get(&self, key: &str) -> Option<&JsonValue> {
        if let JsonValue::Object(map) = self {
            map.get(key)
        } else {
            None
        }
    }

    // 获取 Array 中的元素
    fn index(&self, i: usize) -> Option<&JsonValue> {
        if let JsonValue::Array(arr) = self {
            arr.get(i)
        } else {
            None
        }
    }

    // 简单格式化输出
    fn format(&self, indent: usize) -> String {
        let pad = "  ".repeat(indent);
        match self {
            JsonValue::Null => String::from("null"),
            JsonValue::Bool(b) => format!("{}", b),
            JsonValue::Number(n) => {
                if *n == (*n as i64) as f64 {
                    format!("{}", *n as i64)
                } else {
                    format!("{}", n)
                }
            }
            JsonValue::Str(s) => format!("\"{}\"", s),
            JsonValue::Array(arr) => {
                if arr.is_empty() {
                    return String::from("[]");
                }
                let items: Vec<String> = arr.iter()
                    .map(|v| format!("{}  {}", pad, v.format(indent + 1)))
                    .collect();
                format!("[\n{}\n{}]", items.join(",\n"), pad)
            }
            JsonValue::Object(map) => {
                if map.is_empty() {
                    return String::from("{}");
                }
                let mut keys: Vec<&String> = map.keys().collect();
                keys.sort();
                let entries: Vec<String> = keys.iter()
                    .map(|k| format!("{}  \"{}\": {}",
                        pad, k, map[*k].format(indent + 1)))
                    .collect();
                format!("{{\n{}\n{}}}", entries.join(",\n"), pad)
            }
        }
    }
}

fn main() {
    // 构建一个 JSON 对象
    let mut user = HashMap::new();
    user.insert(String::from("name"), JsonValue::Str(String::from("张三")));
    user.insert(String::from("age"), JsonValue::Number(28.0));
    user.insert(String::from("active"), JsonValue::Bool(true));
    user.insert(String::from("email"), JsonValue::Null);
    user.insert(String::from("tags"), JsonValue::Array(vec![
        JsonValue::Str(String::from("rust")),
        JsonValue::Str(String::from("developer")),
    ]));

    let json = JsonValue::Object(user);

    // 格式化输出
    println!("{}", json.format(0));

    // 安全地访问字段
    println!("\n--- 字段访问 ---");
    if let Some(name) = json.get("name").and_then(|v| v.as_str()) {
        println!("姓名: {}", name);
    }
    if let Some(age) = json.get("age").and_then(|v| v.as_number()) {
        println!("年龄: {}", age as i32);
    }
    if let Some(email) = json.get("email") {
        if email.is_null() {
            println!("邮箱: 未设置");
        }
    }
    if let Some(tags) = json.get("tags") {
        if let Some(first) = tags.index(0).and_then(|v| v.as_str()) {
            println!("第一个标签: {}", first);
        }
    }
}

常见问题 ​

问题一:元组变体和命名字段变体怎么选?

字段数量少(1-2个)且含义明确时用元组变体。字段多或含义不直观时用命名字段变体。命名字段更易读但代码更长。

问题二:能不能在 match 中只匹配部分字段?

可以。命名字段变体用 .. 忽略其余字段:Tcp { dest, .. }。元组变体用 _ 忽略某个位置:Move(x, _)。

问题三:枚举变体的数据遵循所有权规则吗?

完全遵循。match 中绑定变量时,非 Copy 类型会被移动。用 ref 关键字或匹配 & 引用可以避免移动。

问题四:如何修改枚举变体内的数据?

需要用 match 配合 &mut 引用:

rust
enum Counter { Active(u32), Stopped }
fn increment(c: &mut Counter) {
    if let Counter::Active(ref mut n) = c {
        *n += 1;
    }
}

适用场景 ​

  • 协议消息:不同消息类型携带不同结构的数据
  • AST 节点:编译器中的语法树节点
  • 配置值:一个配置项可能是字符串、数字、列表等
  • 事件系统:不同事件附带不同的上下文信息

注意事项 ​

  • 变体数据有三种形式:无数据、元组、命名字段
  • 三种形式可以在同一个枚举中混合使用
  • 枚举大小由最大变体决定,大变体用 Box 优化
  • match 中用 .. 忽略不需要的命名字段
  • 变体数据遵循所有权和借用规则
  • 变体可以嵌套任意类型:结构体、枚举、Vec、HashMap 等

总结 ​

枚举变体携带数据是 Rust 枚举区别于 C 风格枚举的核心特性。每个变体可以是无数据、元组形式或命名字段形式,三种形式可以混合使用。通过 match、if let 等模式匹配语法提取变体中的数据,用 .. 忽略不关心的字段。变体数据可以是任意类型,包括结构体、其他枚举、Vec、HashMap 等复杂类型。枚举的内存大小由最大变体决定,过大的变体建议用 Box 包装以减少整体占用。变体数据完全遵循 Rust 的所有权和借用规则。