Rust 枚举

枚举是 Rust 中用于定义一组相关值的自定义类型。本章节将介绍 Rust 枚举的定义和使用。

枚举定义

使用 enum 关键字定义枚举：

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

fn main() {
    let home = IpAddress::V4(String::from("127.0.0.1"));
    let loopback = IpAddress::V6(String::from("::1"));
    
    println!("Home IP: {:?}", home);
    println!("Loopback IP: {:?}", loopback);
}

枚举变体

枚举的每个可能值称为变体（variant）。变体可以包含不同类型的数据：

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

fn main() {
    let quit = Message::Quit;
    let move_msg = Message::Move { x: 10, y: 20 };
    let write_msg = Message::Write(String::from("Hello"));
    let change_color = Message::ChangeColor(255, 0, 0);
}

枚举方法

可以为枚举定义方法，使用 impl 关键字：

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

impl Message {
    fn call(&self) {
        match self {
            Message::Quit => println!("Quit message"),
            Message::Move { x, y } => println!("Move to ({}, {})", x, y),
            Message::Write(text) => println!("Write: {}", text),
            Message::ChangeColor(r, g, b) => println!("Change color to ({}, {}, {})", r, g, b),
        }
    }
}

fn main() {
    let message = Message::Write(String::from("Hello, Rust!"));
    message.call();
}

Option 枚举

Option 是 Rust 标准库中定义的一个重要枚举，用于表示可能有值或可能没有值的情况：

// Option 枚举的定义
// enum Option<T> {
//     None,
//     Some(T),
// }

fn main() {
    let some_number = Some(5);
    let some_string = Some("Hello");
    let absent_number: Option<i32> = None;
    
    println!("some_number: {:?}", some_number);
    println!("some_string: {:?}", some_string);
    println!("absent_number: {:?}", absent_number);
}

Result 枚举

Result 是 Rust 标准库中定义的另一个重要枚举，用于表示操作可能成功或失败的情况：

// Result 枚举的定义
// enum Result<T, E> {
//     Ok(T),
//     Err(E),
// }

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

fn main() {
    match divide(10.0, 2.0) {
        Ok(result) => println!("Result: {}", result),
        Err(error) => println!("Error: {}", error),
    }
    
    match divide(10.0, 0.0) {
        Ok(result) => println!("Result: {}", result),
        Err(error) => println!("Error: {}", error),
    }
}

模式匹配与枚举

使用 match 语句可以对枚举进行模式匹配：

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

fn value_in_cents(coin: Coin) -> u8 {
    match coin {
        Coin::Penny => 1,
        Coin::Nickel => 5,
        Coin::Dime => 10,
        Coin::Quarter => 25,
    }
}

fn main() {
    let penny = Coin::Penny;
    println!("Penny value: {} cents", value_in_cents(penny));
    
    let quarter = Coin::Quarter;
    println!("Quarter value: {} cents", value_in_cents(quarter));
}

if let 简化匹配

对于只关心一种变体的情况，可以使用 if let 语句简化代码：

fn main() {
    let some_number = Some(5);
    
    if let Some(x) = some_number {
        println!("Number is: {}", x);
    } else {
        println!("No number");
    }
}

总结

• 使用 enum 关键字定义枚举
• 枚举可以包含不同类型的变体
• 可以为枚举定义方法
• Option 枚举用于表示可能有值或可能没有值的情况
• Result 枚举用于表示操作可能成功或失败的情况
• 使用 match 语句对枚举进行模式匹配
• 使用 if let 语句简化枚举匹配

通过本章节的学习，你应该已经掌握了 Rust 枚举的定义和使用方法，可以在你的程序中使用枚举来表示一组相关的值。