Rust基础(5)-枚举与模式匹配

枚举与模式匹配

1. 基础-枚举和match

1. 类似于c语言的方式定义
2. rust语言提倡的方式定义
3. 可以是不同类型
4. 经典用法
5. 枚举类型的方法以及match
   6.备注：
   1. match类似于别的语言的switch，也可以用if替代

//1. 类似于c语言的方式定义
enum IpAddKind {
    V4,
    V6,
}

struct IpAddr {
    kind: IpAddKind,
    address: String,
}

//2. rust语言提倡的方式定义
enum IpAddr2 {
    V4(String),
    V6(String),
}

// 3. 可以是不同类型
enum IpAddr3 {
    V4(u8, u8, u8, u8),
    V6(String),
}

// 4. 经典用法
enum Message {
    Quit,
    Move { x: i32, y: i32 },
    Write(String),
    Change(i32, i32, i32),
}
//--等同于
//struct QuitMessage; //类单元结构体
//struct MoveMessage{
//    x:i32,
//    y:i32,
//}
//struct WriteMessage(String)
//struct Change(i32,i32,i32)

// 5. 枚举类型的方法以及match
impl Message {
    fn prin(&self) {
        match self {
            Message::Quit => println!("Quit"),
            Message::Move{x, y} => println!("Move x = {},y = {}", x, y),
            Message::Change(a, b, c) => println!("change a = {}, b = {}, c = {}", a, b, c),
            //默认，类似default语句
            // _ => println!("Write"),
            Message:: Write(&s) => println!("Write = {}", s) 
        }
    }
}

fn main() {
    // 1. 类似于c语言的方式定义
    let i1 = IpAddr {
        kind: IpAddKind::V4,
        address: String::from("127.0.0.1"),
    };
    let i2 = IpAddr {
        kind: IpAddKind::V6,
        address: String::from("::1"),
    };

    // 2. rust语言提倡的方式定义
    let i1 = IpAddr2::V4(String::from("127.0.0.1"));
    let i2 = IpAddr2::V6(String::from("::1"));

    // 3. 可以是不同类型
    let i1 = IpAddr3::V4(127, 0, 0, 1);
    let i2 = IpAddr3::V6(String::from("::1"));
    // 4. 经典用法
    // Message结构体

    // 5. 枚举类型的方法以及match
    let quit = Message::Quit;
    quit.prin();
    let mo = Message::Move {x:10,y:20};
    mo.prin();
    let wri = Message::Write(String::from("hello"));
    wri.prin();
    let change = Message::Change(1,2,3);
    change.prin();
}

2. Option(重点掌握)

Option是标准库定义的一个枚举。
主要用法：

• 初始化值
• 作为在整个输入范围内没有定义的函数的返回值
• 作为返回值，用None表示出现的简单错误
• 作为结构体的可选字段
• 作为结构体中可借出或者可载入的字段，下方有使用案例
• 作为函数的可选参数
• 代表空指针
• 用作复杂情况的返回值

2.1 基本使用

//Option是标准库定一个的一个枚举，标准库定义格式如下：
//enum Option<T>{
//  Some(T),
//  None,
//}
// match时，Option的所有类型都要匹配到
fn main() {
    let some_number = Some(5);
    let some_string = Some(String::from("a string"));
    let absent_numer: Option<i32> = None;
    let x: i32 = 5;
    let y: Option<i32> = Some(5);
    let mut temp = 0;
    match y {
        Some(i) => { temp = i }
        None => { println!("do notiong") }
    }
    let sum = x + temp;
    println!("sum = {}", sum);

    let result = plus_one(y);
    match result {
        Some(i) => println!("result = {}",i),
        None => println!("nothing"),
    };

    //可以用if来判断
    if let Some(value) = plus_one(y){
        println!("value = {}",value)
    }else{  //处理None
        println!("do noting" )
    }
}

fn plus_one(x: Option<i32>) -> Option<i32> {
    match x {
        None => None,
        Some(x) => Some(x + 1),
    }
}

2.2 基本使用

作为结构体中可借出或者可载入的字段：

use std::thread;
use std::time::Duration;

struct Worker {
    // thread: thread::JoinHandle<()>,
    thread: Option<thread::JoinHandle<()>>,
}

impl Worker {
    fn new() -> Worker {
        let thread = thread::spawn(move || {
            println!("start work 10 secs ...");
            thread::sleep(Duration::from_secs(10));
            println!("start work 10 finish ...");
        });

        Worker { thread:Some(thread)  }
    }
}

struct ThreadPool {
    workers: Vec<Worker>,
}

impl ThreadPool {
    fn new(size: usize) -> ThreadPool {
        assert!(size > 0);
        let mut workers = Vec::with_capacity(size);
        for _ in 0..size {
            workers.push(Worker::new());
        }
        ThreadPool{workers}
    }
}

impl Drop for ThreadPool {
    fn drop(&mut self) {
        for worker in &mut self.workers {
            // worker.thread.join().unwrap();
            // println!("worker thread finished");
            if let Some(thread) = worker.thread.take(){
                thread.join().unwrap();
                println!("worker thread finished");
            }
        }
    }
}

fn main() {
    let pool = ThreadPool::new(3);
}

2.3 常用方法

1. take()：将数据移出赋值给指定变量Some(x )，自身变为None。就是上面案例，将thread从可变数据中移出
2. copied()：从Option<&T>得到Option（通过复制实现）
3. cloned()：从Option<&T>得到Option（通过clone实现）
4. is_some()：当Option中有值，返回true
5. is_none()：当Option为None，返回true
6. contains()：属于nightly版本特性，当Option中包含指定值，则返回true
7. as_ref()：将&Option转换为Option<&T> ，将外部引用转换为内部引用。说白了就是直接指向了内部的T：

fn main() {
    let text:Option<String> = Some("Hello,world!".to_string());
    let text_length: Option<usize> = text.as_ref().map(|s| s.len());
    println!("still can print text:{:?}",text);
}

总结

已编辑完毕

参考

[1] Rust 程序设计语言