Rust从入门到实战系列二百七十五：枚举 Enum

🌟🌟 在创建枚举时，你可以使用显式的整数设定枚举成员的值。
// 修 复 错 误
enum Number {
Zero,
One,
Two,
}
enum Number1 {
Zero = 0,
One,
Two,
}
// C语 言 风 格 的 枚 举 定 义
enum Number2 {
Zero = 0.0,
One = 1.0,
Two = 2.0,
}
fn main() {
// 通 过 as 可 以 将 枚 举 值 强 转 为 整 数 类 型
assert_eq!(Number::One, Number1::One);
assert_eq!(Number1::One, Number2::One);
}
2. 🌟 枚举成员可以持有各种类型的值
// 填 空
enum Message {
Quit,
Move { x: i32, y: i32 },
Write(String),
ChangeColor(i32, i32, i32),
}
fn main() {
let msg1 = Message::Move{}; // 使 用x = 1, y = 2 来 初 始 化
let msg2 = Message::Write(); // 使 用 “hello, world!” 来 初 始 化
}
3. 🌟🌟 枚举成员中的值可以使用模式匹配来获取
// 仅 填 空 并 修 复 错 误
enum Message {
Quit,
Move { x: i32, y: i32 },
Write(String),
ChangeColor(i32, i32, i32),
}
fn main() {
let msg = Message::Move{x: 1, y: 2};
if let Message::Move{} = msg {
assert_eq!(a, b);
} else {
panic!(“不 要 让 这 行 代 码 运 行 ！”);
}
}
4. 🌟🌟 使用枚举对类型进行同一化
// 填 空 ， 并 修 复 错 误
enum Message {
Quit,
Move { x: i32, y: i32 },
Write(String),
ChangeColor(i32, i32, i32),
}
fn main() {
let msgs: __ = [
Message::Quit,
Message::Move{x:1, y:3},
Message::ChangeColor(255,255,0)
];
for msg in msgs {
show_message(msg)
}
}
fn show_message(msg: Message) {
println!(“{}”, msg);
}
5. 🌟🌟 Rust 中没有 null ，我们通过 Option 枚举来处理值为空的情况
// 填 空 让 println 输 出 ， 同 时 添 加 一 些 代 码 不 要 让 最 后 一 行 的 panic 执 行 到
fn main() {
let five = Some(5);
let six = plus_one(five);
let none = plus_one(None);
if let __ = six {
println!(“{}”, n)
}
panic!(“不 要 让 这 行 代 码 运 行 ！”);
}
fn plus_one(x: Option) -> Option {
match x {
__ => None,
__ => Some(i + 1),
}
}
6. 🌟🌟🌟🌟 使用枚举来实现链表.
// 填 空 ， 让 代 码 运 行
use crate::List:😗;
enum List {
// Cons: 链 表 中 包 含 有 值 的 节 点 ， 节 点 是 元 组 类 型 ， 第 一 个 元 素 是 节 点 的 值 ， 第 二 个 元 素 是 指 向
Cons(u32, Box),
// Nil: 链 表 中 的 最 后 一 个 节 点 ， 用 于 说 明 链 表 的 结 束
Nil,
}
// 为 枚 举 实 现 一 些 方 法
impl List {
// 创 建 空 的 链 表
fn new() -> List {
// 因 为 没 有 节 点 ， 所 以 直 接 返 回 Nil 节 点
// 枚 举 成 员 Nil 的 类 型 是 List
Nil
}
// 在 老 的 链 表 前 面 新 增 一 个 节 点 ， 并 返 回 新 的 链 表
fn prepend(self, elem: u32) -> __ {
Cons(elem, Box::new(self))
}
// 返 回 链 表 的 长 度
fn len(&self) -> u32 {
match *self {
// 这 里 我 们 不 能 拿 走 tail 的 所 有 权 ， 因 此 需 要 获 取 它 的 引 用
Cons(_, __ tail) => 1 + tail.len(),
// 空 链 表 的 长 度 为 0
Nil => 0
}
}
// 返 回 链 表 的 字 符 串 表 现 形 式 ， 用 于 打 印 输 出
fn stringify(&self) -> String {
match *self {
Cons(head, ref tail) => {
Cons(head, ref tail) > {
// 递 归 生 成 字 符 串
format!(“{}, {}”, head, tail.())
},
Nil => {
format!(“Nil”)
},
}
}
}
fn main() {
// 创 建 一 个 新 的 链 表(也 是 空 的)
let mut list = List::new();
// 添 加 一 些 元 素
list = list.prepend(1);
list = list.prepend(2);
list = list.prepend(3);
// 打 印 列 表 的 当 前 状 态
println!(“链 表 的 长 度 是: {}”, list.len());
println!(“{}”, list.stringify());
}