Rust 枚举

枚举（或称 enumeration）是一种用户定义的类型，它允许我们从一组相关值中选择一个值。

在 Rust 中，我们使用 enum 关键字来创建枚举。例如：

enum Sport {
    Basketball,
    Volleyball,
    Football,
    Cricket,
}

在这里，我们创建了一个名为 Sport 的枚举，其值为 Basketball、Volleyball、Football 和 Cricket。这些枚举值被称为变体（variants）。

何时在 Rust 中使用枚举

让我们来看一个要定义枚举的场景。

假设你正在创建一个程序，其中需要存储一个方向列表，并且我们知道方向只有四个可能的值：北、东、西和南。

在这种情况下，我们可以使用枚举，其中每个变体都是一个方向。

enum Direction {
    North,
    East,
    South,
    West,
}

现在，每当我们想在程序中使用方向时，都可以访问每个枚举变体。

注意：按照惯例，我们对枚举名称和值使用 Pascal 命名法。在 Pascal 命名法中，我们将单词的首字母大写。

访问 Rust 中的枚举变体

要访问枚举值，我们首先必须创建枚举实例。例如：

enum Direction {
    North,
    East
    South,
    West,
}

现在让我们创建每个枚举变体的实例

let north = Direction::North;
let east = Direction::East;
let south = Direction::South;
let west = Direction::West;

这里，Direction::North 代表 Direction 枚举的 North 枚举变体，我们将其赋值给变量 north。

类似地，Direction::East、Direction::South 和 Direction::West 分别代表变体 East、South 和 West。

Rust 枚举数据类型

现在让我们看一个关于枚举在 Rust 中如何工作的例子。

fn main() {

    // define enum Direction
    #[derive(Debug)]
    enum Direction {
        North,
        East,
        South,
        West,
    }

    // initialize and access enum variants
    let north = Direction::North;
    let east = Direction::East;
    let south = Direction::South;
    let west = Direction::West;

    // print enum values
    println!("{:?}", north);
    println!("{:?}", east);
    println!("{:?}", south);
    println!("{:?}", west);
}

输出

North
East
South
West

在这里，我们创建了枚举实例

• north - 用于访问枚举变体 Direction::North
• east - 用于访问枚举变体 Direction::East
• south - 用于访问枚举变体 Direction::South
• west - 用于访问枚举变体 Direction::West

然后我们打印了这些实例。

注意：我们在枚举定义上方使用了 #[derive(Debug)]。这是因为这允许 Rust 打印枚举内的变体。

示例：Rust 中的枚举数据类型

让我们再看一个例子。

fn main() {

    // define enum color
    #[derive(Debug)]
    enum Color {
        Green,
        Yellow,
        Red,
    }

    // initialize and access enum variants
    let green = Color::Green;
    let yellow = Color::Yellow;
    let red = Color::Red;

    // print enum values
    println!("{:?}", green);
    println!("{:?}", yellow);
    println!("{:?}", red);
}

输出

Green
Yellow
Red

在 Rust 中初始化枚举变体的值

在 Rust 中，我们也可以通过分配单个值来初始化枚举变体。例如：

fn main() {
    // define enum
    #[derive(Debug)]
    enum Result {
        Score(f64),
        Valid(bool),
    }

    // initialize enum with values
    let num = Result::Score(3.14);
    let bool = Result::Valid(true);
    
    println!("num = {:?}", num);
    println!("bool = {:?}", bool);
}

输出

num = Score(3.14)
bool = Valid(true)

在上面的示例中，我们创建了一个名为 Result 的枚举，它有两个变体：Score（f64 类型）和 Valid（布尔类型）。

注意创建枚举实例的语句。

let num = Result::Score(3.14);
let bool = Result::Valid(true);

在这里，我们在括号内使用值初始化枚举变体。即：

• Result::Score(3.14) - 使用值 3.14 初始化 Score 变体
• Result::Valid(true) - 使用值 true 初始化 Valid 变体

具有不同数据类型的 Rust 枚举

在 Rust 中，我们也可以创建枚举，其中枚举变体是不同的数据类型：结构体、元组、字符串等。

1. 带有结构体变体的枚举

enum Game {
    Quit,
    Position { x: i32, y: i32 },
}

这里 Game 枚举有一个匿名的结构体 Position { x: i32, y: i32 } 作为其变体。

2. 带有元组变体的枚举

enum Game {
    Quit,
    ChangeBackground(i32, i32, i32),
}

这里，Game 枚举有一个元组 ChangeBackground(i32, i32, i32) 作为其变体。

3. 带有字符串变体的枚举

enum Game {
    Quit,
    Print(String),
}

这里，Game 枚举有一个 Print(String) 变体。

示例：不同数据类型的枚举变体

前面我们看到枚举变体可以是不同的数据类型。我们甚至可以创建一个枚举，其中每个变体都是不同类型。也就是说，一个变体是字符串，另一个是结构体，依此类推。例如：

enum Game {
    Quit,
    Print(String),
    Position { x: i32, y: i32 },
    ChangeBackground(i32, i32, i32),
}

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

• Quit 没有任何相关数据
• Print 包含一个单独的 String
• Position 包含一个匿名的结构体
• ChangeBackground 包含三个 i32 值（元组）

让我们看一个如何使用此枚举的例子，

fn main() {
    // define enum with multiple variants and data types
    #[derive(Debug)]
    enum Game {
        Quit,
        Print(String),
        Position { x: i32, y: i32 },
        ChangeBackground(i32, i32, i32),
    }

    // initialize enum with values
    let quit = Game::Quit;
    let print = Game::Print(String::from("Hello World!"));
    let position = Game::Position { x: 10, y: 20 };
    let color = Game::ChangeBackground(200, 255, 255);

    // print enum values
    println!("quit = {:?}", quit);
    println!("print = {:?}", print);
    println!("position = {:?}", position);
    println!("color = {:?}", color);
}

在这里，我们根据枚举定义初始化了枚举。

让我们看一下 Game 枚举中的 Position 变体，

enum Game {
    ..
    Position { x: i32, y: i32 }
    ..
}

现在，要赋值，我们以与枚举定义相同的格式定位 Position 变体并用值对其进行初始化。

let position = Game::Position { x: 10, y: 20 };

这里，我们用 x: 10 和 y: 20 初始化了结构体变体 Position。

类似地，我们为所有其他变体赋值并将其打印在屏幕上。

let quit = Game::Quit;
let print = Game::Print(String::from("Hello World!"));
let color = Game::ChangeBackground(200, 255, 255);

Rust 中的可变枚举

要创建可变枚举，我们可以在初始化枚举时使用 mut 关键字。

假设我们有一个枚举，

// enum definition
enum Animal {
    Dog(String, f64),
    Cat(String, f64),
}

// create mutable enum variant
let mut dog = Animal::Dog("Tucker", 37.4);

示例：可变枚举

fn main() {
    // define enum with multiple variants and data types
    #[derive(Debug)]
    enum Animal {
        Dog(String, f64),
        Cat(String, f64),
    }

    // initialize a mutable enum variant with values
    let mut dog = Animal::Dog(String::from("Tucker"), 37.4);
    
    // initialize a non-mutable enum variant with values
    let cat = Animal::Cat(String::from("Maya"), 22.3);

    // print enum values before change
    println!("dog before = {:?}", dog);
    println!("cat before = {:?}", cat);

    // change the value of mutable enum variant
    dog = Animal::Dog(String::from("Sterling"), 21.1);

    // print enum values after change
    println!();
    println!("dog after = {:?}", dog);
    println!("cat after = {:?}", cat);
}

输出

dog before = Dog("Tucker", 37.4)
cat before = Cat("Maya", 22.3)

dog after = Dog("Sterling", 21.1)
cat after = Cat("Maya", 22.3)

在这里，我们初始化了一个枚举变体，并使用 mut 关键字将其赋值给变量 dog。

let mut dog = Animal::Dog(String::from("Tucker"), 37.4);

这允许我们更改 dog 变量的值。在上面的程序中，我们将 dog 变量更改为：

dog = Animal::Dog(String::from("Sterling"), 21.1);

结果，变量 dog 的值从 Dog("Tucker", 37.4) 更改为 Dog("Sterling", 21.1)。