枚举 Enum

枚举 Enum

🌟🌟 在创建枚举时，你可以使用显式的整数设定枚举成员的值。

2. // 修复错误
3. enum Number {
4. Zero,
5. One,
6. Two,
7. }

9. enum Number1 {
10. Zero = 0,
11. One,
12. Two,
13. }

15. // C语言风格的枚举定义
16. enum Number2 {
17. Zero = 0.0,
18. One = 1.0,
19. Two = 2.0,
20. }

22. fn main() {
23. // 通过 `as` 可以将枚举值强转为整数类型
24. assert_eq!(Number::One, Number1::One);
25. assert_eq!(Number1::One, Number2::One);
26. }

🌟 枚举成员可以持有各种类型的值

2. // 填空
3. enum Message {
4. Quit,
5. Move { x: i32, y: i32 },
6. Write(String),
7. ChangeColor(i32, i32, i32),
8. }

10. fn main() {
11. let msg1 = Message::Move{__}; // 使用x = 1, y = 2 来初始化
12. let msg2 = Message::Write(__); // 使用 "hello, world!" 来初始化
13. }

🌟🌟 枚举成员中的值可以使用模式匹配来获取

2. // 仅填空并修复错误
3. enum Message {
4. Quit,
5. Move { x: i32, y: i32 },
6. Write(String),
7. ChangeColor(i32, i32, i32),
8. }

10. fn main() {
11. let msg = Message::Move{x: 1, y: 2};

13. if let Message::Move{__} = msg {
14. assert_eq!(a, b);
15. } else {
16. panic!("不要让这行代码运行！");
17. }
18. }

🌟🌟 使用枚举对类型进行同一化

2. // 填空，并修复错误
3. enum Message {
4. Quit,
5. Move { x: i32, y: i32 },
6. Write(String),
7. ChangeColor(i32, i32, i32),
8. }

10. fn main() {
11. let msgs: __ = [
12. Message::Quit,
13. Message::Move{x:1, y:3},
14. Message::ChangeColor(255,255,0)
15. ];

17. for msg in msgs {
18. show_message(msg)
19. }
20. }

22. fn show_message(msg: Message) {
23. println!("{}", msg);
24. }

🌟🌟 Rust 中没有 null，我们通过 Option<T> 枚举来处理值为空的情况

2. // 填空让 `println` 输出，同时添加一些代码不要让最后一行的 `panic` 执行到
3. fn main() {
4. let five = Some(5);
5. let six = plus_one(five);
6. let none = plus_one(None);

8. if let __ = six {
9. println!("{}", n)
10. }

12. panic!("不要让这行代码运行！");
13. }

15. fn plus_one(x: Option<i32>) -> Option<i32> {
16. match x {
17. __ => None,
18. __ => Some(i + 1),
19. }
20. }

🌟🌟🌟🌟 使用枚举来实现链表.

2. // 填空，让代码运行
3. use crate::List::*;

5. enum List {
6. // Cons: 链表中包含有值的节点，节点是元组类型，第一个元素是节点的值，第二个元素是指向下一个节点的指针
7. Cons(u32, Box<List>),
8. // Nil: 链表中的最后一个节点，用于说明链表的结束
9. Nil,
10. }

12. // 为枚举实现一些方法
13. impl List {
14. // 创建空的链表
15. fn new() -> List {
16. // 因为没有节点，所以直接返回 Nil 节点
17. // 枚举成员 Nil 的类型是 List
18. Nil
19. }

21. // 在老的链表前面新增一个节点，并返回新的链表
22. fn prepend(self, elem: u32) -> __ {
23. Cons(elem, Box::new(self))
24. }

26. // 返回链表的长度
27. fn len(&self) -> u32 {
28. match *self {
29. // 这里我们不能拿走 tail 的所有权，因此需要获取它的引用
30. Cons(_, __ tail) => 1 + tail.len(),
31. // 空链表的长度为 0
32. Nil => 0
33. }
34. }

36. // 返回链表的字符串表现形式，用于打印输出
37. fn stringify(&self) -> String {
38. match *self {
39. Cons(head, ref tail) => {
40. // 递归生成字符串
41. format!("{}, {}", head, tail.__())
42. },
43. Nil => {
44. format!("Nil")
45. },
46. }
47. }
48. }

50. fn main() {
51. // 创建一个新的链表(也是空的)
52. let mut list = List::new();

54. // 添加一些元素
55. list = list.prepend(1);
56. list = list.prepend(2);
57. list = list.prepend(3);

59. // 打印列表的当前状态
60. println!("链表的长度是: {}", list.len());
61. println!("{}", list.stringify());
62. }

你可以在这里找到答案(在 solutions 路径下)

6.6. 枚举

枚举 Enum