Rust 中的枚举

枚举的定义

• 通过enum 关键字来定义枚举

fn main() {
    let run = ThreadState::Running;
    let sleep = ThreadState::Sleeping;

    print_state(run);
    print_state(sleep);
}

enum ThreadState {
    Running,
    Sleeping,
}

fn print_state(state: ThreadState) {
    match state {
        ThreadState::Running => println!("Running"),
        ThreadState::Sleeping => println!("Sleeping"),
    }
}

/* 输出：
Running
Sleeping
*/

• 给枚举中的变体绑定值

当一个枚举中的变体绑定的有值时，仍然可以通过match 语句来进行匹配，并且可以在匹配后获取到绑定到该变体上的值；当然也可以通过if let 语句来直接提取枚举变量中变体所绑定的值

fn main() {
    let run = State::Running(String::from("Running state"));
    let sleep = State::Sleeping(String::from("Sleeping state"));

    // 通过 match 匹配并获取变体中的值
    print_state(&run);
    print_state(&sleep);

    // 通过 if let 匹配并获取变体中的值
    if let State::Running(str) = run {
        println!("Running state: {}", str);
    }
    if let State::Sleeping(str) = sleep {
        println!("Sleeping state: {}", str);
    }
}

enum State {
    Running(String),
    Sleeping(String),
}

fn print_state(state: &State) {
    match state {
        State::Running(str) => {
            println!("Match Running: {}", str);
        }
        State::Sleeping(str) => {
            println!("Match Sleeping: {}", str);
        }
    }
}

/* 输出：
Match Running: Running state
Match Sleeping: Sleeping state
Running state: Running state
Sleeping state: Sleeping state
*/

• 枚举中定义方法

fn main() {
    let run = State::Running;
    let sleep = State::Sleeping;

    State::say_hello();
    run.print_info();
    sleep.print_info();
}

enum State {
    Running,
    Sleeping,
}

impl State {
    fn print_info(&self) {
        match *self {
            State::Running => println!("Running State"),
            State::Sleeping => println!("Sleeping State"),
        }
    }

    fn say_hello() {
        println!("Hello");
    }
}

/* 输出：
Hello
Running State
Sleeping State
*/

Option枚举

• Rust中没有Null值，因此用Option来表示一个变量可能为空，例如Option<i32>表示该变量可能有值，也可能为空。

Option在标准库中的定义

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

• 需要注意的是Some<T>不等同于T，它们是两种不同的类型，如果想从Some<T>中提取T可以使用match或if let等语句\

使用样例

fn main() {
    let x = 50;
    let y = 123;

    let m = test(x);
    let n = test(y);

    // 通过 if let 来获取 Some<T> 中的 T
    if let Some(m) = m {
        println!("m = {}", m);
    }
    if let Some(n) = n {
        println!("n = {}", n);
    }

    // 通过 match 来获取 Some<T> 中的 T
    match m {
        Some(m) => println!("m = {}", m),
        None => println!("m = None"),
    }
    match n {
        Some(n) => println!("n = {}", n),
        None => println!("n = None"),
    }
}

fn test(a: i32) -> Option<i32> {
    if a > 100 {
        Some(a)
    } else {
        None
    }
}

/* 输出：
n = 123
m = None
n = 123
*/