Rust 程序设计语言

定义枚举

结构体为您提供了一种将相关字段和数据组合在一起的方法，例如具有 width 和 height 的 Rectangle，而枚举则为您提供了一种说明值是可能值集合之一的方法。 例如，我们可能想说 Rectangle 是一组可能的形状之一，其中还包括 Circle 和 Triangle。 为了做到这一点，Rust 允许我们将这些可能性编码为枚举。

让我们看看我们可能想在代码中表达的情况，并了解为什么在这种情况下枚举有用且比结构体更合适。 假设我们需要处理 IP 地址。 目前，IP 地址使用两个主要标准：版本四和版本六。 因为这些是我们的程序将遇到的 IP 地址的唯一可能性，所以我们可以枚举所有可能的变体，这也是枚举得名的原因。

任何 IP 地址都可以是版本四地址或版本六地址，但不能同时是两者。 IP 地址的这种属性使枚举数据结构非常适合，因为枚举值只能是其变体之一。 版本四和版本六地址在根本上仍然是 IP 地址，因此当代码处理适用于任何类型的 IP 地址的情况时，应将它们视为同一类型。

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

enum IpAddrKind {
    V4,
    V6,
}

fn main() {
    let four = IpAddrKind::V4;
    let six = IpAddrKind::V6;

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

fn route(ip_kind: IpAddrKind) {}

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

枚举值

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

enum IpAddrKind {
    V4,
    V6,
}

fn main() {
    let four = IpAddrKind::V4;
    let six = IpAddrKind::V6;

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

fn route(ip_kind: IpAddrKind) {}

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

enum IpAddrKind {
    V4,
    V6,
}

fn main() {
    let four = IpAddrKind::V4;
    let six = IpAddrKind::V6;

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

fn route(ip_kind: IpAddrKind) {}

我们可以使用任一变体调用此函数

enum IpAddrKind {
    V4,
    V6,
}

fn main() {
    let four = IpAddrKind::V4;
    let six = IpAddrKind::V6;

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

fn route(ip_kind: IpAddrKind) {}

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

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

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

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

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

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

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

#![allow(unused)]
fn main() {
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),
}

fn main() {}

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

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

• Quit 完全没有关联数据。
• Move 具有命名字段，就像结构体一样。
• Write 包括一个 String。
• ChangeColor 包括三个 i32 值。

定义具有变体（例如清单 6-2 中的变体）的枚举类似于定义不同类型的结构体定义，除了枚举不使用 struct 关键字，并且所有变体都分组在 Message 类型下。 以下结构体可以保存与前面的枚举变体相同的数据

struct QuitMessage; // unit struct
struct MoveMessage {
    x: i32,
    y: i32,
}
struct WriteMessage(String); // tuple struct
struct ChangeColorMessage(i32, i32, i32); // tuple struct

fn main() {}

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

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

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

    impl Message {
        fn call(&self) {
            // method body would be defined here
        }
    }

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

该方法的主体将使用 self 来获取我们调用该方法的 value。 在此示例中，我们创建了一个变量 m，它的值为 Message::Write(String::from("hello"))，这就是当 m.call() 运行时 self 在 call 方法主体中的值。

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

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

本节探讨 Option 的案例研究，Option 是标准库定义的另一个枚举。 Option 类型编码了一种非常常见的情况，即一个值可能是某个东西，也可能什么都不是。

例如，如果您请求非空列表中的第一项，您将获得一个值。 如果您请求空列表中的第一项，您将一无所获。 用类型系统表达这个概念意味着编译器可以检查您是否处理了所有应该处理的情况； 此功能可以防止在其他编程语言中极其常见的错误。

编程语言设计通常从您包含哪些功能来考虑，但您排除的功能也很重要。 Rust 没有许多其他语言都具有的 null 功能。 Null 是一个值，表示那里没有值。 在具有 null 的语言中，变量始终可以处于两种状态之一：null 或非 null。

在其 2009 年的演讲“空引用：价值十亿美元的错误”中，null 的发明者 Tony Hoare 这样说

我称之为我价值十亿美元的错误。 那时，我正在为面向对象语言中的引用设计第一个全面的类型系统。 我的目标是确保引用的所有使用都应该是绝对安全的，并由编译器自动执行检查。 但我无法抗拒放入空引用的诱惑，仅仅因为它太容易实现了。 这导致了无数的错误、漏洞和系统崩溃，在过去的四十年里，这可能造成了价值十亿美元的痛苦和损失。

空值的问题在于，如果您尝试将空值用作非空值，您将得到某种错误。 因为这种空或非空属性是普遍存在的，所以很容易犯这种错误。

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

问题实际上不在于概念，而在于特定的实现。 因此，Rust 没有 null，但它有一个枚举可以编码值存在或不存在的概念。 此枚举是 Option<T>，并且 由标准库定义如下所示

#![allow(unused)]
fn main() {
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 值来保存数字类型和字符串类型的示例

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

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

简而言之，因为 Option<T> 和 T（其中 T 可以是任何类型）是不同的类型，所以编译器不允许我们像使用确定是有效值一样使用 Option<T> 值。 例如，以下代码不会编译，因为它试图将 i8 添加到 Option<i8>

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

    let sum = x + y;
}

如果我们运行此代码，我们会收到如下错误消息

$ cargo run
   Compiling enums v0.1.0 (file:///projects/enums)
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`
  = help: the following other types implement trait `Add<Rhs>`:
            `&'a i8` implements `Add<i8>`
            `&i8` implements `Add<&i8>`
            `i8` implements `Add<&i8>`
            `i8` implements `Add`

For more information about this error, try `rustc --explain E0277`.
error: could not compile `enums` (bin "enums") due to 1 previous error

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

换句话说，您必须先将 Option<T> 转换为 T，然后才能对其执行 T 操作。 通常，这有助于捕获 null 最常见的错误之一：假设某些东西不是 null，而实际上它是 null。

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

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

一般来说，为了使用 Option<T> 值，您需要拥有将处理每个变体的代码。 您需要一些仅在您具有 Some(T) 值时才会运行的代码，并且此代码允许使用内部 T。 您需要一些其他代码，仅当您具有 None 值时才会运行，并且该代码没有可用的 T 值。 match 表达式是一种控制流结构，当与枚举一起使用时，它正是这样做的：它将根据它拥有的枚举的哪个变体运行不同的代码，并且该代码可以使用匹配值内的数据。