枚举变体与数据
核心概念
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 的所有权和借用规则。