02-枚举 on 编程那些事儿

01-使用 use

Thu, 20 Aug 2026 21:20:00 +0800

译文 · 基于 Rust By Example

原文链接: https://doc.rust-lang.org/stable/rust-by-example/custom_types/enum/enum_use.html

使用 use

使用 use 声明的话，就可以不写出名称的完整路径了：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36


// 该属性用于隐藏对未使用代码的警告。
#![allow(dead_code)]

enum Status {
 Rich,
 Poor,
}

enum Work {
 Civilian,
 Soldier,
}

fn main() {
 // 显式地 `use` 各个名称使他们直接可用，而不需要指定它们来自 `Status`。
 use Status::{Poor, Rich};
 // 自动地 `use` `Work` 内部的各个名称。
 use Work::*;

 // `Poor` 等价于 `Status::Poor`。
 let status = Poor;
 // `Civilian` 等价于 `Work::Civilian`。
 let work = Civilian;

 match status {
 // 注意这里没有用完整路径，因为上面显式地使用了 `use`。
 Rich => println!("The rich have lots of money!"),
 Poor => println!("The poor have no money..."), // The poor have no money...
 }

 match work {
 // 再次注意到没有用完整路径。
 Civilian => println!("Civilians work!"), // Civilians work!
 Soldier => println!("Soldiers fight!"),
 }
}

参见：

match 和 use

02-C 风格用法

Thu, 20 Aug 2026 21:20:00 +0800

译文 · 基于 Rust By Example

原文链接: https://doc.rust-lang.org/stable/rust-by-example/custom_types/enum/c_like.html

C 风格用法

enum 也可以像 C 语言风格的枚举类型那样使用。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


// 该属性用于隐藏对未使用代码的警告。
#![allow(dead_code)]

// 拥有隐式辨别值（implicit discriminator，从 0 开始）的 enum
enum Number {
 Zero,
 One,
 Two,
}

// 拥有显式辨别值（explicit discriminator）的 enum
enum Color {
 Red = 0xff0000,
 Green = 0x00ff00,
 Blue = 0x0000ff,
}

fn main() {
 // `enum` 可以转成整型。
 println!("zero is {}", Number::Zero as i32); // zero is 0
 println!("one is {}", Number::One as i32); // one is 1

 println!("roses are #{:06x}", Color::Red as i32); // roses are #ff0000
 println!("violets are #{:06x}", Color::Blue as i32); // violets are #0000ff
}

参考：

类型转换

03-测试实例：链表

Thu, 20 Aug 2026 21:20:00 +0800

译文 · 基于 Rust By Example

原文链接: https://doc.rust-lang.org/stable/rust-by-example/custom_types/enum/testcase_linked_list.html

测试实例：链表

enum 的一个常见用法就是创建链表（linked-list）：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66


use List::*;

enum List {
 // Cons：元组结构体，包含链表的一个元素和一个指向下一节点的指针
 Cons(u32, Box<List>),
 // Nil：末结点，表明链表结束
 Nil,
}

// 可以为 enum 定义方法
impl List {
 // 创建一个空的 List 实例
 fn new() -> List {
 // `Nil` 为 `List` 类型（译注：因 `Nil` 的完整名称是 `List::Nil`）
 Nil
 }

 // 处理一个 List，在其头部插入新元素，并返回该 List
 fn prepend(self, elem: u32) -> List {
 // `Cons` 同样为 List 类型
 Cons(elem, Box::new(self))
 }

 // 返回 List 的长度
 fn len(&self) -> u32 {
 // 必须对 `self` 进行匹配（match），因为这个方法的行为取决于 `self` 的
 // 取值种类。
 // `self` 为 `&List` 类型，`*self` 为 `List` 类型，匹配一个具体的 `T`
 // 类型要好过匹配引用 `&T`。
 match *self {
 // 不能得到 tail 的所有权，因为 `self` 是借用的；
 // 因此使用一个对 tail 的引用
 Cons(_, ref tail) => 1 + tail.len(),
 // （递归的）基准情形（base case）：一个长度为 0 的空列表
 Nil => 0
 }
 }

 // 返回列表的字符串表示（该字符串是堆分配的）
 fn stringify(&self) -> String {
 match *self {
 Cons(head, ref tail) => {
 // `format!` 和 `print!` 类似，但返回的是一个堆分配的字符串，
 // 而不是打印结果到控制台上
 format!("{}, {}", head, tail.stringify())
 },
 Nil => {
 format!("Nil")
 },
 }
 }
}

fn main() {
 // 创建一个空链表
 let mut list = List::new();

 // 追加一些元素
 list = list.prepend(1);
 list = list.prepend(2);
 list = list.prepend(3);

 // 显示链表的最后状态
 println!("linked list has length: {}", list.len()); // linked list has length: 3
 println!("{}", list.stringify()); // 3, 2, 1, Nil
}

参见：

Box 和方法