定义枚举

简介

欢迎来到「定义枚举」实验。本实验是 《Rust 程序设计语言》 的一部分。你可以在 LabEx 中练习 Rust 技能。

在本实验中，我们将定义一个名为 IpAddrKind 的枚举，以表示 IP 地址的可能类型，包括 IPv4 (V4) 和 IPv6 (V6)。

Skills Graph

定义枚举

结构体为你提供了一种将相关字段和数据组合在一起的方式，比如带有 width 和 height 的 Rectangle；而枚举则为你提供了一种方式，表明一个值是一组可能值中的一个。例如，我们可能想说 Rectangle 是一组可能形状中的一种，这组形状还包括 Circle 和 Triangle。为此，Rust 允许我们将这些可能性编码为一个枚举。

让我们来看一个可能想用代码表达的情况，看看为什么枚举在这种情况下是有用的，并且比结构体更合适。假设我们需要处理 IP 地址。目前，IP 地址使用两种主要标准：版本 4 和版本 6。因为我们的程序遇到的 IP 地址只有这两种可能性，所以我们可以 枚举 所有可能的变体，这就是枚举名称的由来。

任何 IP 地址要么是版本 4 地址，要么是版本 6 地址，但不能同时是两者。IP 地址的这个特性使得枚举数据结构很合适，因为枚举值只能是其变体之一。版本 4 和版本 6 地址从根本上来说仍然都是 IP 地址，所以当代码处理适用于任何类型 IP 地址的情况时，它们应该被视为同一类型。

我们可以通过定义一个 IpAddrKind 枚举并列出 IP 地址可能的类型 V4 和 V6，在代码中表达这个概念。这些就是枚举的变体：

enum IpAddrKind {
    V4,
    V6,
}

IpAddrKind 现在是一个自定义数据类型，我们可以在代码的其他地方使用它。

枚举值

我们可以像这样创建 IpAddrKind 的两个变体的实例：

let four = IpAddrKind::V4;
let six = IpAddrKind::V6;

注意，枚举的变体在其标识符下进行了命名空间划分，我们使用双冒号将两者分隔开。这很有用，因为现在 IpAddrKind::V4 和 IpAddrKind::V6 这两个值都是同一类型：IpAddrKind。例如，我们可以定义一个接受任何 IpAddrKind 的函数：

fn route(ip_kind: IpAddrKind) {}

然后我们可以使用任何一个变体来调用这个函数：

route(IpAddrKind::V4);
route(IpAddrKind::V6);

使用枚举还有更多优点。再考虑一下我们的 IP 地址类型，目前我们没有办法存储实际的 IP 地址 数据；我们只知道它是哪种 类型。鉴于你刚刚在第 5 章中学到了结构体，你可能会想用结构体来解决这个问题，如清单 6-1 所示。

1 enum IpAddrKind {
    V4,
    V6,
}

2 struct IpAddr {
  3 kind: IpAddrKind,
  4 address: String,
}

5 let home = IpAddr {
    kind: IpAddrKind::V4,
    address: String::from("127.0.0.1"),
};

6 let loopback = IpAddr {
    kind: IpAddrKind::V6,
    address: String::from("::1"),
};

清单 6-1：使用 struct 存储 IP 地址的数据和 IpAddrKind 变体

在这里，我们定义了一个结构体 IpAddr [2]，它有两个字段：一个 kind 字段 [3]，其类型为 IpAddrKind（我们之前定义的枚举 [1]），以及一个 address 字段 [4]，其类型为 String。我们有这个结构体的两个实例。第一个是 home [5]，它的 kind 值为 IpAddrKind::V4，关联的地址数据为 127.0.0.1。第二个实例是 loopback [6]。它的 kind 值是 IpAddrKind 的另一个变体 V6，并关联地址 ::1。我们使用结构体将 kind 和 address 值捆绑在一起，所以现在变体与值相关联。

然而，仅使用枚举来表示相同的概念更简洁：我们不是在结构体中使用枚举，而是可以直接将数据放入每个枚举变体中。IpAddr 枚举的这个新定义表示 V4 和 V6 变体都将有相关联的 String 值：

enum IpAddr {
    V4(String),
    V6(String),
}

let home = IpAddr::V4(String::from("127.0.0.1"));

let loopback = IpAddr::V6(String::from("::1"));

我们直接将数据附加到枚举的每个变体上，所以不需要额外的结构体。在这里，也更容易看出枚举工作方式的另一个细节：我们定义的每个枚举变体的名称也成为了一个构造枚举实例的函数。也就是说，IpAddr::V4() 是一个函数调用，它接受一个 String 参数并返回一个 IpAddr 类型的实例。定义枚举时会自动为我们定义这个构造函数。

使用枚举而不是结构体还有另一个优点：每个变体可以有不同类型和数量的关联数据。IPv4 地址总是有四个数字组件，其值在 0 到 255 之间。如果我们想将 V4 地址存储为四个 u8 值，但仍然将 V6 地址表示为一个 String 值，使用结构体就无法做到。枚举轻松地处理这种情况：

enum IpAddr {
    V4(u8, u8, u8, u8),
    V6(String),
}

let home = IpAddr::V4(127, 0, 0, 1);

let loopback = IpAddr::V6(String::from("::1"));

我们展示了几种不同的方法来定义数据结构以存储 IPv4 和 IPv6 地址。然而，事实证明，想要存储 IP 地址并编码它们的类型是非常常见的，以至于标准库有一个我们可以使用的定义！让我们看看标准库是如何定义 IpAddr 的：它有我们定义和使用的完全相同的枚举和变体，但它以两个不同结构体的形式将地址数据嵌入到变体中，每个变体的定义都不同：

struct Ipv4Addr {
    --snip--
}

struct Ipv6Addr {
    --snip--
}

enum IpAddr {
    V4(Ipv4Addr),
    V6(Ipv6Addr),
}

这段代码说明你可以在枚举变体中放入任何类型的数据：例如字符串、数字类型或结构体。你甚至可以包含另一个枚举！此外，标准库类型通常并不比你自己想出的复杂多少。

请注意，即使标准库包含了 IpAddr 的定义，我们仍然可以创建并使用我们自己的定义而不会产生冲突，因为我们没有将标准库的定义引入到我们的作用域中。我们将在第 7 章中更多地讨论将类型引入作用域的问题。

让我们看一下清单 6-2 中枚举的另一个示例：这个枚举的变体中嵌入了各种各样的类型。

enum Message {
    Quit,
    Move { x: i32, y: i32 },
    Write(String),
    ChangeColor(i32, i32, i32),
}

清单 6-2：一个 Message 枚举，其变体各自存储不同数量和类型的值

这个枚举有四个具有不同类型的变体：

• Quit 根本没有关联的数据。
• Move 有命名字段，就像结构体一样。
• Write 包含一个 String。
• ChangeColor 包含三个 i32 值。

定义一个具有如清单 6-2 中变体的枚举类似于定义不同种类的结构体定义，只是枚举不使用 struct 关键字，并且所有变体都在 Message 类型下组合在一起。以下结构体可以保存与前面枚举变体相同的数据：

struct QuitMessage; // 单元结构体
struct MoveMessage {
    x: i32,
    y: i32,
}
struct WriteMessage(String); // 元组结构体
struct ChangeColorMessage(i32, i32, i32); // 元组结构体

但是如果我们使用不同的结构体，每个结构体都有自己的类型，我们就不能像使用清单 6-2 中定义的 Message 枚举那样轻松地定义一个函数来接受任何这些类型的消息，因为 Message 枚举是一个单一类型。

枚举和结构体之间还有一个相似之处：就像我们能够使用 impl 为结构体定义方法一样，我们也能够为枚举定义方法。这是我们可以在 Message 枚举上定义的一个名为 call 的方法：

impl Message {
    fn call(&self) {
      1 // 方法体将在此处定义
    }
}

2 let m = Message::Write(String::from("hello"));
m.call();

方法体将使用 self 来获取调用该方法的值。在这个例子中，我们创建了一个变量 m [2]，其值为 Message::Write(String::from("hello"))，当 m.call() 运行时，self 在 call 方法体 [1] 中将是这个值。

让我们看一下标准库中另一个非常常见且有用的枚举：Option。

Option 枚举及其相对于空值的优势

本节将探讨 Option 的一个案例研究，它是标准库定义的另一个枚举。Option 类型编码了一种非常常见的情况：一个值可能存在，也可能不存在。

例如，如果你请求包含多个元素的列表中的第一个元素，你会得到一个值。如果你请求空列表中的第一个元素，你将得不到任何值。用类型系统来表达这个概念意味着编译器可以检查你是否处理了所有应该处理的情况；这种功能可以防止在其他编程语言中极为常见的错误。

编程语言设计通常会考虑要包含哪些特性，但你排除的特性也很重要。Rust 没有许多其他语言所具有的空值特性。空值 是一个表示那里没有值的值。在有空值的语言中，变量总是可以处于两种状态之一：空值或非空值。

在 2009 年的演讲《空引用：十亿美元的错误》中，空值的发明者托尼·霍尔（Tony Hoare）是这样说的：

我称它为我十亿美元的错误。当时，我正在为一种面向对象语言设计第一个全面的引用类型系统。我的目标是确保所有引用的使用都绝对安全，由编译器自动进行检查。但我忍不住诱惑加入了一个空引用，仅仅是因为它很容易实现。这导致了无数的错误、漏洞和系统崩溃，在过去的四十年里，这些可能已经造成了十亿美元的痛苦和损失。空值的问题在于，如果你试图将一个空值用作非空值，你会得到某种错误。因为这种空值或非空值的属性无处不在，所以极容易犯这种错误。

然而，空值试图表达的概念仍然是有用的：空值是一个由于某种原因当前无效或不存在的值。

问题并不真正在于这个概念，而在于具体的实现。因此，Rust 没有空值，但它有一个枚举，可以编码值存在或不存在的概念。这个枚举是 Option<T>，标准库将其定义如下：

enum Option<T> {
    None,
    Some(T),
}

Option<T> 枚举非常有用，甚至包含在标准库 prelude 中；你不需要显式地将其引入作用域。它的变体也包含在 prelude 中：你可以直接使用 Some 和 None，而无需 Option:: 前缀。Option<T> 枚举仍然只是一个普通的枚举，Some(T) 和 None 仍然是 Option<T> 类型的变体。

<T> 语法是 Rust 中一个我们尚未讨论过的特性。它是一个泛型类型参数，我们将在第 10 章更详细地介绍泛型。目前，你只需要知道 <T> 意味着 Option 枚举的 Some 变体可以持有任何类型的一块数据，并且每个用于替换 T 的具体类型都会使整个 Option<T> 类型成为不同的类型。以下是一些使用 Option 值来持有数字类型和字符串类型的示例：

let some_number = Some(5);
let some_char = Some('e');

let absent_number: Option<i32> = None;

some_number 的类型是 Option<i32>。some_char 的类型是 Option<char>，这是一个不同的类型。Rust 可以推断这些类型，因为我们在 Some 变体中指定了一个值。对于 absent_number，Rust 要求我们注释整个 Option 类型：编译器仅通过查看一个 None 值无法推断出相应 Some 变体将持有的类型。在这里，我们告诉 Rust，我们希望 absent_number 是 Option<i32> 类型。

当我们有一个 Some 值时，我们知道有一个值存在，并且该值保存在 Some 中。当我们有一个 None 值时，在某种意义上它与空值的含义相同：我们没有一个有效的值。那么为什么使用 Option<T> 比使用空值更好呢？

简而言之，因为 Option<T> 和 T（其中 T 可以是任何类型）是不同的类型，编译器不会让我们将 Option<T> 值当作肯定是有效的值来使用。例如，这段代码不会编译，因为它试图将一个 i8 与一个 Option<i8> 相加：

let x: i8 = 5;
let y: Option<i8> = Some(5);

let sum = x + y;

如果我们运行这段代码，我们会得到如下错误消息：

error[E0277]: cannot add `Option<i8>` to `i8`
 --> src/main.rs:5:17
  |
5 |     let sum = x + y;
  |                 ^ no implementation for `i8 + Option<i8>`
  |
  = help: the trait `Add<Option<i8>>` is not implemented for `i8`

很严重！实际上，这个错误消息意味着 Rust 不知道如何将一个 i8 和一个 Option<i8> 相加，因为它们是不同的类型。在 Rust 中，当我们有一个像 i8 这样类型的值时，编译器会确保我们始终有一个有效的值。在使用该值之前，我们可以放心地继续，而不必检查是否为空值。只有当我们有一个 Option<i8>（或我们正在处理的任何类型的值）时，我们才需要担心可能没有值，并且编译器会确保我们在使用该值之前处理这种情况。

换句话说，在对 Option<T> 执行 T 操作之前，你必须将其转换为 T。一般来说，这有助于捕获与空值最常见的问题之一：假设某个东西不为空而实际上它为空。

消除错误地假设非空值的风险有助于你对代码更有信心。为了拥有一个可能为空的值，你必须通过将该值的类型设为 Option<T> 来明确选择。然后，当你使用该值时，你需要明确处理该值为空的情况。在任何值的类型不是 Option<T> 的地方，你 可以 安全地假设该值不为空。这是 Rust 的一个有意设计决策，以限制空值的普遍性并提高 Rust 代码的安全性。

那么，当你有一个 Option<T> 类型的值时，如何从 Some 变体中获取 T 值以便使用该值呢？Option<T> 枚举有大量在各种情况下都很有用的方法；你可以在其文档中查看它们。熟悉 Option<T> 上的方法在你学习 Rust 的过程中会非常有用。

一般来说，为了使用 Option<T> 值，你需要编写能够处理每个变体的代码。你需要一些仅在你有 Some(T) 值时才运行的代码，并且这段代码可以使用内部的 T。你还需要一些仅在你有 None 值时才运行的代码，并且那段代码没有可用的 T 值。match 表达式是一种控制流结构，当与枚举一起使用时，它就可以做到这一点：它会根据它所拥有的枚举变体运行不同的代码，并且那段代码可以使用匹配值内部的数据。

总结

恭喜你！你已经完成了「定义枚举」实验。你可以在 LabEx 中练习更多实验来提升你的技能。