06-rust基础 枚举-Enum

在 Rust 中，enum 是一种非常强大的类型，它允许定义一组具有关联性的可能值。与许多编程语言中的枚举不同，Rust 的枚举不仅可以是简单的枚举值，还可以包含数据，甚至可以和结构体一样复杂。

以下是对 enum 的全面学习和总结：

---

1. 基本枚举

枚举的基本形式是定义一组可能的值：

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

fn move_direction(direction: Direction) {
    match direction {
        Direction::North => println!("Going North"),
        Direction::South => println!("Going South"),
        Direction::East => println!("Going East"),
        Direction::West => println!("Going West"),
    }
}

fn main() {
    let direction = Direction::North;
    move_direction(direction);
}

特点：

• 每个变体可以直接被匹配和使用。
• 使用 match 是处理枚举的主要方式。

---

2. 枚举变体可以携带数据

与普通的枚举不同，Rust 的 enum 允许为每个变体附加数据。

enum Shape {
    Circle(f64),            // 半径
    Rectangle(f64, f64),    // 宽度和高度
    Triangle { base: f64, height: f64 }, // 使用结构体样式的字段
}

fn area(shape: Shape) -> f64 {
    match shape {
        Shape::Circle(radius) => 3.14 * radius * radius,
        Shape::Rectangle(width, height) => width * height,
        Shape::Triangle { base, height } => 0.5 * base * height,
    }
}

fn main() {
    let circle = Shape::Circle(5.0);
    let rectangle = Shape::Rectangle(3.0, 4.0);
    let triangle = Shape::Triangle { base: 6.0, height: 4.0 };

    println!("Circle area: {}", area(circle));
    println!("Rectangle area: {}", area(rectangle));
    println!("Triangle area: {}", area(triangle));
}

特点：

• 每个变体可以携带不同类型和数量的数据。
• 可使用结构体风格来定义字段以增加可读性。

---

3. Option 和 Result 是枚举

Option 和 Result 是 Rust 标准库中定义的两个非常常见的枚举。

Option

Option 表示一个值可能存在，也可能不存在：

fn divide(a: f64, b: f64) -> Option<f64> {
    if b != 0.0 {
        Some(a / b)
    } else {
        None
    }
}

fn main() {
    let result = divide(4.0, 2.0);
    match result {
        Some(value) => println!("Result is: {}", value),
        None => println!("Cannot divide by zero!"),
    }
}

Result

Result 表示一个操作可能成功，也可能失败：

fn divide(a: f64, b: f64) -> Result<f64, String> {
    if b != 0.0 {
        Ok(a / b)
    } else {
        Err(String::from("Cannot divide by zero"))
    }
}

fn main() {
    match divide(4.0, 0.0) {
        Ok(value) => println!("Result is: {}", value),
        Err(err) => println!("Error: {}", err),
    }
}

特点：

• Option 和 Result 都是枚举，使用非常广泛。
• 通过 match 或者 .unwrap() 等方法处理其值。

---

4. 方法实现

可以为枚举实现方法，增强其实用性。

enum TrafficLight {
    Red,
    Yellow,
    Green,
}

impl TrafficLight {
    fn action(&self) {
        match self {
            TrafficLight::Red => println!("Stop!"),
            TrafficLight::Yellow => println!("Prepare to stop."),
            TrafficLight::Green => println!("Go!"),
        }
    }
}

fn main() {
    let light = TrafficLight::Green;
    light.action();
}

---

5. 使用 #[derive] 自动生成功能

可以为枚举派生一些常见的特性，如 Debug、Clone、PartialEq 等。

#[derive(Debug, PartialEq)]
enum Status {
    Active,
    Inactive,
    Suspended,
}

fn main() {
    let status = Status::Active;
    println!("{:?}", status);

    if status == Status::Active {
        println!("The status is active!");
    }
}

---

6. 枚举的泛型支持

枚举可以使用泛型来增加灵活性：

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

fn main() {
    let number: Container<i32> = Container::Some(42);
    let text: Container<&str> = Container::Some("Hello");

    match number {
        Container::Some(value) => println!("Number: {}", value),
        Container::None => println!("No number"),
    }

    match text {
        Container::Some(value) => println!("Text: {}", value),
        Container::None => println!("No text"),
    }
}

---

7. match 与 if let 的使用

处理枚举时，if let 是一种简洁的方式：

enum Coin {
    Penny,
    Nickel,
    Dime,
    Quarter,
}

fn main() {
    let coin = Coin::Quarter;

    // 使用 match
    match coin {
        Coin::Penny => println!("It's a penny."),
        Coin::Nickel => println!("It's a nickel."),
        Coin::Dime => println!("It's a dime."),
        Coin::Quarter => println!("It's a quarter."),
    }

    // 使用 if let
    if let Coin::Quarter = coin {
        println!("It's a quarter.");
    }
}

---

8. 总结

Rust 中的枚举是一个非常强大的工具，用于表示有限的、可能的状态。以下是关键点：

1. 基本枚举：类似于其他语言的枚举，表示一组常量值。
2. 携带数据的枚举：每个变体可以包含数据，类似于结构体。
3. 泛型枚举：可以使用泛型定义更灵活的枚举类型。
4. 标准库中的枚举：如 Option 和 Result 是枚举的典型例子。
5. match 和 if let：主要用于处理枚举的匹配逻辑。
6. 方法实现：为枚举定义行为。

Rust 的枚举比传统编程语言中功能更强大，非常适合表达复杂的逻辑状态和数据流。