第9课：枚举与Option

🎯 本课目标

掌握Rust枚举定义、Option类型、模式匹配枚举，以及代数数据类型概念。

1. 枚举定义

enum IpAddr {
    V4(u8, u8, u8, u8),
    V6(String),
}

enum Shape {
    Circle { radius: f64 },
    Rectangle { width: f64, height: f64 },
    Triangle { a: f64, b: f64, c: f64 },
}

fn area(s: &Shape) -> f64 {
    match s {
        Shape::Circle { radius } => std::f64::consts::PI * radius * radius,
        Shape::Rectangle { width, height } => width * height,
        Shape::Triangle { a, b, c } => {
            let s = (a + b + c) / 2.0;
            (s * (s-a) * (s-b) * (s-c)).sqrt()
        }
    }
}

fn main() {
    let home = IpAddr::V4(127, 0, 0, 1);
    let loopback = IpAddr::V6(String::from("::1"));

    let shapes: Vec<Shape> = vec![
        Shape::Circle { radius: 5.0 },
        Shape::Rectangle { width: 3.0, height: 4.0 },
        Shape::Triangle { a: 3.0, b: 4.0, c: 5.0 },
    ];
    for s in &shapes {
        println!("面积: {:.2}", area(s));
    }
}

✅ 编译验证通过

2. Option — 空值的替代

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

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

fn main() {
    let result = divide(10.0, 3.0);
    match result {
        Some(v) => println!("结果: {:.2}", v),
        None => println!("除零错误"),
    }

    // if let简洁写法
    if let Some(v) = divide(10.0, 2.0) {
        println!("if let: {}", v);
    }

    // unwrap — None时panic
    // let v = divide(10.0, 0.0).unwrap();  // 💥

    // unwrap_or — 提供默认值
    let v = divide(10.0, 0.0).unwrap_or(0.0);
    println!("默认值: {}", v);
}

✅ 编译验证通过

3. Option的常用方法

fn main() {
    let some: Option<i32> = Some(42);
    let none: Option<i32> = None;

    // map — 转换Some中的值
    let doubled = some.map(|x| x * 2);     // Some(84)
    let none_d = none.map(|x| x * 2);     // None

    // and_then — 链式操作（flatMap）
    let result = Some(2)
        .and_then(|x| divide(10.0, x as f64))
        .map(|v| v * 3.0);

    // filter — 条件过滤
    let positive = Some(5).filter(|&x| x > 0);  // Some(5)
    let negative = Some(-5).filter(|&x| x > 0); // None

    // unwrap_or_else
    let v = None.<i32>.unwrap_or_else(|| 0);

    // ok_or — 转为Result
    let r = None.<i32>.ok_or("not found");
}

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

✅ 编译验证通过

4. 代数数据类型

5. 枚举与链表

enum List {
    Cons(i32, Box<List>),
    Nil,
}

fn sum(list: &List) -> i32 {
    match list {
        List::Cons(head, tail) => head + sum(tail),
        List::Nil => 0,
    }
}

fn main() {
    let list = List::Cons(1,
        Box::new(List::Cons(2,
            Box::new(List::Cons(3,
                Box::new(List::Nil))))));
    println!("sum = {}", sum(&list));
}

✅ 编译验证通过

📝 练习题

📚 扩展阅读

🔑 关键术语回顾

💬 学习建议

🤔 常见问题