📚 第6章：控制流

“程序的逻辑就像河流，控制流决定了它的流向。” —— Rust开发者

控制流是编程的核心概念，它决定了程序的执行路径。Rust提供了丰富而强大的控制流结构，包括条件语句、循环、迭代器和闭包等。本章将深入探讨这些概念，帮助你编写更加优雅和高效的Rust代码。

学习目标

通过本章学习，你将掌握：

• 🎯 条件语句和模式匹配
• 🔄 各种循环结构的使用
• 🚀 迭代器的强大功能
• 📦 闭包的定义和应用
• ⚡ 函数式编程技巧
• 🛡️ 错误处理模式

---

6.1 条件语句

6.1.1 if表达式

Rust中的if是表达式，不是语句，这意味着它可以返回值。

fn main() {
    println!("🎯 条件语句示例");
    println!("===============");
    
    // 基本if表达式
    let number = 6;
    
    if number % 4 == 0 {
        println!("数字能被4整除");
    } else if number % 3 == 0 {
        println!("数字能被3整除");
    } else if number % 2 == 0 {
        println!("数字能被2整除");
    } else {
        println!("数字不能被4、3或2整除");
    }
    
    // if作为表达式
    let condition = true;
    let number = if condition { 5 } else { 6 };
    println!("number的值是: {}", number);
    
    // 复杂条件判断
    let age = 25;
    let has_license = true;
    let has_car = false;
    
    let can_drive = if age >= 18 && has_license {
        if has_car {
            "可以开车"
        } else {
            "有驾照但没有车"
        }
    } else {
        "不能开车"
    };
    
    println!("驾驶状态: {}", can_drive);
    
    // 使用if let进行模式匹配
    let some_number = Some(7);
    
    if let Some(x) = some_number {
        println!("匹配到数字: {}", x);
    } else {
        println!("没有匹配到数字");
    }
    
    // 多重if let
    let values = vec![Some(1), None, Some(3)];
    
    for value in values {
        if let Some(x) = value {
            if x > 2 {
                println!("找到大于2的值: {}", x);
            } else {
                println!("找到小于等于2的值: {}", x);
            }
        } else {
            println!("找到None值");
        }
    }
    
    demonstrate_advanced_conditions();
}

fn demonstrate_advanced_conditions() {
    println!("\n高级条件判断:");
    
    // 使用函数作为条件
    let numbers = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
    
    for num in &numbers {
        let description = if is_even(*num) {
            "偶数"
        } else if is_prime(*num) {
            "奇质数"
        } else {
            "奇合数"
        };
        
        println!("{} 是 {}", num, description);
    }
    
    // 条件链
    let score = 85;
    let grade = if score >= 90 {
        'A'
    } else if score >= 80 {
        'B'
    } else if score >= 70 {
        'C'
    } else if score >= 60 {
        'D'
    } else {
        'F'
    };
    
    println!("分数 {} 对应等级 {}", score, grade);
    
    // 复杂的布尔逻辑
    let weather = "sunny";
    let temperature = 25;
    let has_umbrella = false;
    
    let should_go_out = match weather {
        "sunny" => temperature > 15 && temperature < 35,
        "rainy" => has_umbrella,
        "cloudy" => temperature > 10,
        _ => false,
    };
    
    println!("是否应该出门: {}", should_go_out);
}

fn is_even(n: i32) -> bool {
    n % 2 == 0
}

fn is_prime(n: i32) -> bool {
    if n < 2 {
        return false;
    }
    for i in 2..=(n as f64).sqrt() as i32 {
        if n % i == 0 {
            return false;
        }
    }
    true
}

rustc conditional_basics.rs && ./conditional_basics

6.1.2 match表达式进阶

fn main() {
    println!("🎯 高级match表达式");
    println!("=================");
    
    demonstrate_match_guards();
    demonstrate_match_bindings();
    demonstrate_match_ranges();
    demonstrate_match_destructuring();
}

fn demonstrate_match_guards() {
    println!("\n守卫条件:");
    
    let pair = (2, -2);
    
    match pair {
        (x, y) if x == y => println!("这些是双胞胎"),
        (x, y) if x + y == 0 => println!("反义词！"),
        (x, _) if x % 2 == 1 => println!("第一个是奇数"),
        _ => println!("没有相关性..."),
    }
    
    // 复杂守卫条件
    let numbers = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
    
    for num in numbers {
        let description = match num {
            x if x % 15 == 0 => "FizzBuzz",
            x if x % 3 == 0 => "Fizz",
            x if x % 5 == 0 => "Buzz",
            x if x > 7 => "大数",
            _ => "普通数",
        };
        
        println!("{}: {}", num, description);
    }
}

fn demonstrate_match_bindings() {
    println!("\n绑定匹配:");
    
    #[derive(Debug)]
    enum Message {
        Hello { id: i32 },
        Move { x: i32, y: i32 },
        Write(String),
        ChangeColor(i32, i32, i32),
    }
    
    let msg = Message::ChangeColor(0, 160, 255);
    
    match msg {
        Message::Hello { id: id_variable @ 3..=7 } => {
            println!("找到一个在范围内的id: {}", id_variable);
        }
        Message::Hello { id: 10..=12 } => {
            println!("找到另一个范围内的id");
        }
        Message::Hello { id } => {
            println!("找到其他id: {}", id);
        }
        Message::Move { x, y } => {
            println!("移动到坐标 ({}, {})", x, y);
        }
        Message::Write(text) => {
            println!("文本消息: {}", text);
        }
        Message::ChangeColor(r, g, b) => {
            println!("改变颜色为红: {}, 绿: {}, 蓝: {}", r, g, b);
        }
    }
    
    // @ 绑定
    let point = (3, 5);
    
    match point {
        p @ (x, y) if x > 0 && y > 0 => {
            println!("点 {:?} 在第一象限", p);
        }
        (x, y) if x < 0 && y > 0 => {
            println!("点在第二象限");
        }
        (x, y) if x < 0 && y < 0 => {
            println!("点在第三象限");
        }
        (x, y) if x > 0 && y < 0 => {
            println!("点在第四象限");
        }
        _ => println!("点在坐标轴上"),
    }
}

fn demonstrate_match_ranges() {
    println!("\n范围匹配:");
    
    let x = 5;
    
    match x {
        1..=5 => println!("一到五"),
        6..=10 => println!("六到十"),
        11..=20 => println!("十一到二十"),
        _ => println!("其他"),
    }
    
    // 字符范围
    let letter = 'c';
    
    match letter {
        'a'..='j' => println!("早期字母"),
        'k'..='z' => println!("后期字母"),
        _ => println!("其他字符"),
    }
    
    // 多个范围
    let age = 25;
    
    let category = match age {
        0..=2 => "婴儿",
        3..=12 => "儿童",
        13..=19 => "青少年",
        20..=39 => "青年",
        40..=59 => "中年",
        60..=79 => "老年",
        80..=120 => "高龄",
        _ => "超出范围",
    };
    
    println!("年龄 {} 属于 {} 阶段", age, category);
}

fn demonstrate_match_destructuring() {
    println!("\n解构匹配:");
    
    // 解构结构体
    #[derive(Debug)]
    struct Point {
        x: i32,
        y: i32,
    }
    
    let points = vec![
        Point { x: 0, y: 0 },
        Point { x: 1, y: 5 },
        Point { x: 10, y: -3 },
        Point { x: -1, y: -1 },
    ];
    
    for point in points {
        match point {
            Point { x: 0, y: 0 } => println!("原点"),
            Point { x: 0, y } => println!("在Y轴上，y = {}", y),
            Point { x, y: 0 } => println!("在X轴上，x = {}", x),
            Point { x, y } if x == y => println!("对角线上的点 ({}, {})", x, y),
            Point { x, y } if x > 0 && y > 0 => println!("第一象限的点 ({}, {})", x, y),
            Point { x, y } => println!("其他位置的点 ({}, {})", x, y),
        }
    }
    
    // 解构元组
    let tuples = vec![
        (1, 2, 3),
        (4, 5, 6),
        (7, 8, 9),
        (0, 0, 0),
    ];
    
    for tuple in tuples {
        match tuple {
            (0, 0, 0) => println!("全零元组"),
            (x, y, z) if x == y && y == z => println!("所有元素相等: {}", x),
            (x, y, z) if x + y + z == 15 => println!("元素和为15: ({}, {}, {})", x, y, z),
            (x, ..) if x > 5 => println!("第一个元素大于5: {}", x),
            (.., z) if z < 5 => println!("最后一个元素小于5: {}", z),
            (x, y, z) => println!("普通元组: ({}, {}, {})", x, y, z),
        }
    }
    
    // 解构数组
    let arrays = vec![
        [1, 2, 3],
        [4, 5, 6],
        [1, 1, 1],
        [0, 0, 0],
    ];
    
    for array in arrays {
        match array {
            [0, 0, 0] => println!("全零数组"),
            [x, y, z] if x == y && y == z => println!("所有元素相等: {}", x),
            [1, x, y] => println!("以1开头: [1, {}, {}]", x, y),
            [x, y, 6] => println!("以6结尾: [{}, {}, 6]", x, y),
            [x, y, z] => println!("普通数组: [{}, {}, {}]", x, y, z),
        }
    }
}

rustc advanced_match.rs && ./advanced_match

6.2 循环结构

6.2.1 基本循环

fn main() {
    println!("🔄 循环结构示例");
    println!("===============");
    
    demonstrate_loop();
    demonstrate_while();
    demonstrate_for();
    demonstrate_nested_loops();
}

fn demonstrate_loop() {
    println!("\nloop循环:");
    
    let mut counter = 0;
    
    let result = loop {
        counter += 1;
        
        if counter == 10 {
            break counter * 2;
        }
        
        if counter % 2 == 0 {
            println!("偶数计数: {}", counter);
        }
    };
    
    println!("loop返回值: {}", result);
    
    // 带标签的循环
    let mut count = 0;
    'counting_up: loop {
        println!("count = {}", count);
        let mut remaining = 10;
        
        loop {
            println!("remaining = {}", remaining);
            if remaining == 9 {
                break;
            }
            if count == 2 {
                break 'counting_up;
            }
            remaining -= 1;
        }
        
        count += 1;
    }
    println!("结束计数 = {}", count);
}

fn demonstrate_while() {
    println!("\nwhile循环:");
    
    let mut number = 3;
    
    while number != 0 {
        println!("{}!", number);
        number -= 1;
    }
    
    println!("发射！！！");
    
    // while let循环
    let mut stack = Vec::new();
    stack.push(1);
    stack.push(2);
    stack.push(3);
    
    println!("\n使用while let弹出栈元素:");
    while let Some(top) = stack.pop() {
        println!("弹出: {}", top);
    }
    
    // 条件复杂的while循环
    let mut x = 1;
    let mut y = 1;
    
    println!("\n斐波那契数列（前10项）:");
    let mut count = 0;
    while count < 10 {
        println!("第{}项: {}", count + 1, x);
        let temp = x + y;
        x = y;
        y = temp;
        count += 1;
    }
}

fn demonstrate_for() {
    println!("\nfor循环:");
    
    // 遍历数组
    let a = [10, 20, 30, 40, 50];
    
    for element in a {
        println!("值是: {}", element);
    }
    
    // 使用范围
    println!("\n使用范围:");
    for number in 1..4 {
        println!("{}!", number);
    }
    
    // 包含结束值的范围
    println!("\n包含结束值的范围:");
    for number in 1..=5 {
        println!("数字: {}", number);
    }
    
    // 反向遍历
    println!("\n反向遍历:");
    for number in (1..4).rev() {
        println!("{}!", number);
    }
    
    // 带索引的遍历
    let names = vec!["Alice", "Bob", "Charlie", "David"];
    
    println!("\n带索引的遍历:");
    for (index, name) in names.iter().enumerate() {
        println!("第{}个名字是: {}", index + 1, name);
    }
    
    // 遍历HashMap
    use std::collections::HashMap;
    
    let mut scores = HashMap::new();
    scores.insert("Blue", 10);
    scores.insert("Yellow", 50);
    scores.insert("Red", 25);
    
    println!("\n遍历HashMap:");
    for (key, value) in &scores {
        println!("{}: {}", key, value);
    }
    
    // 步长遍历
    println!("\n步长遍历（每隔2个）:");
    for i in (0..10).step_by(2) {
        println!("步长遍历: {}", i);
    }
}

fn demonstrate_nested_loops() {
    println!("\n嵌套循环:");
    
    // 乘法表
    println!("九九乘法表:");
    for i in 1..=9 {
        for j in 1..=i {
            print!("{} × {} = {:2}  ", j, i, i * j);
        }
        println!();
    }
    
    // 矩阵遍历
    let matrix = [
        [1, 2, 3],
        [4, 5, 6],
        [7, 8, 9],
    ];
    
    println!("\n矩阵遍历:");
    for (row_index, row) in matrix.iter().enumerate() {
        for (col_index, &value) in row.iter().enumerate() {
            println!("matrix[{}][{}] = {}", row_index, col_index, value);
        }
    }
    
    // 带标签的嵌套循环
    println!("\n查找第一个大于20的乘积:");
    'outer: for i in 1..=10 {
        for j in 1..=10 {
            let product = i * j;
            if product > 20 {
                println!("找到: {} × {} = {}", i, j, product);
                break 'outer;
            }
        }
    }
}

rustc loops_basics.rs && ./loops_basics

6.2.2 循环控制

fn main() {
    println!("🎮 循环控制示例");
    println!("===============");
    
    demonstrate_break_continue();
    demonstrate_loop_labels();
    demonstrate_loop_patterns();
}

fn demonstrate_break_continue() {
    println!("\nbreak和continue:");
    
    // continue示例
    println!("跳过偶数:");
    for i in 1..=10 {
        if i % 2 == 0 {
            continue;
        }
        println!("奇数: {}", i);
    }
    
    // break示例
    println!("\n找到第一个大于50的平方数:");
    for i in 1..20 {
        let square = i * i;
        if square > 50 {
            println!("{}的平方是{}, 大于50", i, square);
            break;
        }
        println!("{}的平方是{}", i, square);
    }
    
    // 复杂的continue逻辑
    println!("\n处理数字（跳过特定条件）:");
    for i in 1..=20 {
        // 跳过能被3整除但不能被9整除的数
        if i % 3 == 0 && i % 9 != 0 {
            continue;
        }
        
        // 跳过个位数是7的数
        if i % 10 == 7 {
            continue;
        }
        
        println!("处理数字: {}", i);
    }
}

fn demonstrate_loop_labels() {
    println!("\n循环标签:");
    
    // 多层循环的标签控制
    'search: for x in 1..=5 {
        'inner: for y in 1..=5 {
            println!("检查 ({}, {})", x, y);
            
            if x == 3 && y == 3 {
                println!("找到目标点 (3, 3)!");
                break 'search;
            }
            
            if y == 2 {
                println!("跳过当前行的剩余部分");
                continue 'search;
            }
        }
    }
    
    // 复杂的标签使用
    println!("\n复杂标签示例:");
    let mut found = false;
    
    'outer: for i in 1..=3 {
        'middle: for j in 1..=3 {
            'inner: for k in 1..=3 {
                println!("检查 ({}, {}, {})", i, j, k);
                
                if i + j + k == 6 {
                    println!("找到和为6的组合: ({}, {}, {})", i, j, k);
                    found = true;
                    break 'outer;
                }
                
                if k == 2 {
                    continue 'middle;
                }
            }
        }
    }
    
    if found {
        println!("搜索完成，找到结果");
    } else {
        println!("搜索完成，未找到结果");
    }
}

fn demonstrate_loop_patterns() {
    println!("\n循环模式:");
    
    // 无限循环模式
    let mut attempts = 0;
    let target = 42;
    
    loop {
        attempts += 1;
        let guess = attempts * 7; // 模拟某种计算
        
        println!("尝试 {}: 猜测值 {}", attempts, guess);
        
        if guess == target {
            println!("找到目标值！");
            break;
        }
        
        if attempts >= 10 {
            println!("达到最大尝试次数");
            break;
        }
    }
    
    // 条件循环模式
    println!("\n处理队列:");
    let mut queue = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
    
    while !queue.is_empty() {
        if let Some(item) = queue.pop() {
            println!("处理项目: {}", item);
            
            // 某些条件下重新加入队列
            if item % 3 == 0 && item > 3 {
                queue.insert(0, item - 1);
                println!("重新加入: {}", item - 1);
            }
        }
        
        // 防止无限循环
        if queue.len() > 15 {
            println!("队列过长，停止处理");
            break;
        }
    }
    
    // 迭代器模式
    println!("\n迭代器模式:");
    let numbers = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
    
    // 链式操作
    let result: Vec<i32> = numbers
        .iter()
        .filter(|&&x| x % 2 == 0)  // 过滤偶数
        .map(|&x| x * x)           // 平方
        .filter(|&x| x > 10)       // 过滤大于10的
        .collect();
    
    println!("处理结果: {:?}", result);
    
    // 早期退出模式
    println!("\n早期退出模式:");
    let data = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
    
    for (index, &value) in data.iter().enumerate() {
        println!("处理索引 {}, 值 {}", index, value);
        
        // 多个退出条件
        if value > 7 {
            println!("值过大，退出");
            break;
        }
        
        if index > 5 {
            println!("索引过大，退出");
            break;
        }
        
        // 跳过某些值
        if value % 3 == 0 {
            println!("跳过能被3整除的值");
            continue;
        }
        
        println!("成功处理值: {}", value);
    }
}

rustc loop_control.rs && ./loop_control

6.3 迭代器

6.3.1 迭代器基础

fn main() {
    println!("🚀 迭代器基础");
    println!("============");
    
    demonstrate_iterator_creation();
    demonstrate_iterator_adaptors();
    demonstrate_consuming_adaptors();
    demonstrate_iterator_performance();
}

fn demonstrate_iterator_creation() {
    println!("\n创建迭代器:");
    
    // 从集合创建迭代器
    let vec = vec![1, 2, 3, 4, 5];
    
    // iter() - 借用引用
    println!("使用iter()（借用）:");
    for item in vec.iter() {
        println!("  {}", item);
    }
    
    // into_iter() - 获取所有权
    let vec2 = vec![1, 2, 3, 4, 5];
    println!("\n使用into_iter()（所有权）:");
    for item in vec2.into_iter() {
        println!("  {}", item);
    }
    // vec2在这里不能再使用
    
    // iter_mut() - 可变借用
    let mut vec3 = vec![1, 2, 3, 4, 5];
    println!("\n使用iter_mut()（可变借用）:");
    for item in vec3.iter_mut() {
        *item *= 2;
        println!("  {}", item);
    }
    println!("修改后的vec3: {:?}", vec3);
    
    // 范围迭代器
    println!("\n范围迭代器:");
    for i in 0..5 {
        println!("  范围值: {}", i);
    }
    
    // 字符串迭代器
    let text = "Hello";
    println!("\n字符迭代器:");
    for ch in text.chars() {
        println!("  字符: {}", ch);
    }
    
    // 字节迭代器
    println!("\n字节迭代器:");
    for byte in text.bytes() {
        println!("  字节: {}", byte);
    }
}

fn demonstrate_iterator_adaptors() {
    println!("\n迭代器适配器:");
    
    let numbers = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
    
    // map - 转换每个元素
    let squares: Vec<i32> = numbers
        .iter()
        .map(|x| x * x)
        .collect();
    println!("平方: {:?}", squares);
    
    // filter - 过滤元素
    let evens: Vec<&i32> = numbers
        .iter()
        .filter(|&&x| x % 2 == 0)
        .collect();
    println!("偶数: {:?}", evens);
    
    // enumerate - 添加索引
    println!("\n带索引的迭代:");
    for (index, value) in numbers.iter().enumerate() {
        println!("  索引 {}: 值 {}", index, value);
    }
    
    // zip - 组合两个迭代器
    let names = vec!["Alice", "Bob", "Charlie"];
    let ages = vec![25, 30, 35];
    
    println!("\n组合迭代器:");
    for (name, age) in names.iter().zip(ages.iter()) {
        println!("  {} 年龄 {}", name, age);
    }
    
    // take - 取前n个元素
    let first_five: Vec<&i32> = numbers
        .iter()
        .take(5)
        .collect();
    println!("\n前5个元素: {:?}", first_five);
    
    // skip - 跳过前n个元素
    let skip_five: Vec<&i32> = numbers
        .iter()
        .skip(5)
        .collect();
    println!("跳过前5个元素: {:?}", skip_five);
    
    // chain - 连接迭代器
    let vec1 = vec![1, 2, 3];
    let vec2 = vec![4, 5, 6];
    let chained: Vec<&i32> = vec1
        .iter()
        .chain(vec2.iter())
        .collect();
    println!("连接迭代器: {:?}", chained);
    
    // 复杂的链式操作
    let result: Vec<i32> = numbers
        .iter()
        .filter(|&&x| x > 3)        // 过滤大于3的
        .map(|x| x * 2)             // 乘以2
        .filter(|&&x| x < 20)       // 过滤小于20的
        .map(|x| x + 1)             // 加1
        .collect();
    
    println!("\n复杂链式操作结果: {:?}", result);
}

fn demonstrate_consuming_adaptors() {
    println!("\n消费适配器:");
    
    let numbers = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
    
    // collect - 收集到集合
    let doubled: Vec<i32> = numbers
        .iter()
        .map(|x| x * 2)
        .collect();
    println!("收集结果: {:?}", doubled);
    
    // reduce/fold - 累积操作
    let sum = numbers
        .iter()
        .fold(0, |acc, x| acc + x);
    println!("求和: {}", sum);
    
    let product = numbers
        .iter()
        .fold(1, |acc, x| acc * x);
    println!("求积: {}", product);
    
    // find - 查找第一个匹配的元素
    let found = numbers
        .iter()
        .find(|&&x| x > 5);
    match found {
        Some(value) => println!("找到第一个大于5的数: {}", value),
        None => println!("没有找到大于5的数"),
    }
    
    // any - 检查是否有任何元素满足条件
    let has_even = numbers
        .iter()
        .any(|&&x| x % 2 == 0);
    println!("是否有偶数: {}", has_even);
    
    // all - 检查是否所有元素都满足条件
    let all_positive = numbers
        .iter()
        .all(|&&x| x > 0);
    println!("是否都是正数: {}", all_positive);
    
    // count - 计数
    let even_count = numbers
        .iter()
        .filter(|&&x| x % 2 == 0)
        .count();
    println!("偶数个数: {}", even_count);
    
    // max/min - 最大值/最小值
    let max_value = numbers.iter().max();
    let min_value = numbers.iter().min();
    println!("最大值: {:?}, 最小值: {:?}", max_value, min_value);
    
    // partition - 分割
    let (evens, odds): (Vec<&i32>, Vec<&i32>) = numbers
        .iter()
        .partition(|&&x| x % 2 == 0);
    println!("偶数: {:?}, 奇数: {:?}", evens, odds);
}

fn demonstrate_iterator_performance() {
    println!("\n迭代器性能:");
    
    let large_vec: Vec<i32> = (0..1_000_000).collect();
    
    // 使用迭代器（零成本抽象）
    let start = std::time::Instant::now();
    let sum_iter: i32 = large_vec
        .iter()
        .filter(|&&x| x % 2 == 0)
        .map(|x| x * x)
        .sum();
    let duration_iter = start.elapsed();
    
    // 使用传统循环
    let start = std::time::Instant::now();
    let mut sum_loop = 0;
    for &x in &large_vec {
        if x % 2 == 0 {
            sum_loop += x * x;
        }
    }
    let duration_loop = start.elapsed();
    
    println!("迭代器结果: {}, 耗时: {:?}", sum_iter, duration_iter);
    println!("循环结果: {}, 耗时: {:?}", sum_loop, duration_loop);
    println!("结果相等: {}", sum_iter == sum_loop);
    
    // 惰性求值演示
    println!("\n惰性求值演示:");
    let lazy_iter = (0..10)
        .map(|x| {
            println!("处理: {}", x);
            x * x
        })
        .filter(|&x| x > 10);
    
    println!("创建了惰性迭代器，但还没有执行");
    
    let result: Vec<i32> = lazy_iter.take(3).collect();
    println!("收集前3个结果: {:?}", result);
}

rustc iterators_basics.rs && ./iterators_basics

6.3.2 自定义迭代器

fn main() {
    println!("🔧 自定义迭代器");
    println!("==============");
    
    demonstrate_counter();
    demonstrate_fibonacci();
    demonstrate_range_iterator();
    demonstrate_tree_iterator();
}

// 简单计数器迭代器
struct Counter {
    current: usize,
    max: usize,
}

impl Counter {
    fn new(max: usize) -> Counter {
        Counter { current: 0, max }
    }
}

impl Iterator for Counter {
    type Item = usize;
    
    fn next(&mut self) -> Option<Self::Item> {
        if self.current < self.max {
            let current = self.current;
            self.current += 1;
            Some(current)
        } else {
            None
        }
    }
}

fn demonstrate_counter() {
    println!("\n计数器迭代器:");
    
    let counter = Counter::new(5);
    
    for num in counter {
        println!("计数: {}", num);
    }
    
    // 使用迭代器方法
    let counter2 = Counter::new(10);
    let sum: usize = counter2
        .filter(|&x| x % 2 == 0)
        .map(|x| x * x)
        .sum();
    
    println!("偶数平方和: {}", sum);
}

// 斐波那契迭代器
struct Fibonacci {
    current: u64,
    next: u64,
    count: usize,
    max_count: usize,
}

impl Fibonacci {
    fn new(max_count: usize) -> Fibonacci {
        Fibonacci {
            current: 0,
            next: 1,
            count: 0,
            max_count,
        }
    }
}

impl Iterator for Fibonacci {
    type Item = u64;
    
    fn next(&mut self) -> Option<Self::Item> {
        if self.count >= self.max_count {
            return None;
        }
        
        let current = self.current;
        self.current = self.next;
        self.next = current + self.next;
        self.count += 1;
        
        Some(current)
    }
}

fn demonstrate_fibonacci() {
    println!("\n斐波那契迭代器:");
    
    let fib = Fibonacci::new(10);
    
    for (i, num) in fib.enumerate() {
        println!("斐波那契第{}项: {}", i + 1, num);
    }
    
    // 找到第一个大于100的斐波那契数
    let fib2 = Fibonacci::new(20);
    if let Some(large_fib) = fib2.find(|&x| x > 100) {
        println!("第一个大于100的斐波那契数: {}", large_fib);
    }
}

// 自定义范围迭代器
struct StepRange {
    current: i32,
    end: i32,
    step: i32,
}

impl StepRange {
    fn new(start: i32, end: i32, step: i32) -> StepRange {
        StepRange {
            current: start,
            end,
            step,
        }
    }
}

impl Iterator for StepRange {
    type Item = i32;
    
    fn next(&mut self) -> Option<Self::Item> {
        if (self.step > 0 && self.current < self.end) || 
           (self.step < 0 && self.current > self.end) {
            let current = self.current;
            self.current += self.step;
            Some(current)
        } else {
            None
        }
    }
}

fn demonstrate_range_iterator() {
    println!("\n步长范围迭代器:");
    
    // 正向步长
    println!("正向步长2:");
    let range1 = StepRange::new(0, 10, 2);
    for num in range1 {
        println!("  {}", num);
    }
    
    // 反向步长
    println!("\n反向步长3:");
    let range2 = StepRange::new(20, 5, -3);
    for num in range2 {
        println!("  {}", num);
    }
    
    // 使用collect收集
    let range3 = StepRange::new(1, 20, 4);
    let collected: Vec<i32> = range3.collect();
    println!("\n收集的步长范围: {:?}", collected);
}

// 二叉树迭代器
#[derive(Debug)]
struct TreeNode {
    value: i32,
    left: Option<Box<TreeNode>>,
    right: Option<Box<TreeNode>>,
}

impl TreeNode {
    fn new(value: i32) -> Self {
        TreeNode {
            value,
            left: None,
            right: None,
        }
    }
    
    fn with_children(value: i32, left: Option<Box<TreeNode>>, right: Option<Box<TreeNode>>) -> Self {
        TreeNode { value, left, right }
    }
}

struct TreeIterator {
    stack: Vec<Box<TreeNode>>,
}

impl TreeIterator {
    fn new(root: Option<Box<TreeNode>>) -> Self {
        let mut stack = Vec::new();
        if let Some(node) = root {
            stack.push(node);
        }
        TreeIterator { stack }
    }
}

impl Iterator for TreeIterator {
    type Item = i32;
    
    fn next(&mut self) -> Option<Self::Item> {
        if let Some(node) = self.stack.pop() {
            // 先推入右子树，再推入左子树（因为栈是后进先出）
            if let Some(right) = node.right {
                self.stack.push(right);
            }
            if let Some(left) = node.left {
                self.stack.push(left);
            }
            
            Some(node.value)
        } else {
            None
        }
    }
}

fn demonstrate_tree_iterator() {
    println!("\n二叉树迭代器:");
    
    // 构建一个简单的二叉树
    //       1
    //      / \
    //     2   3
    //    / \
    //   4   5
    
    let tree = Some(Box::new(TreeNode::with_children(
        1,
        Some(Box::new(TreeNode::with_children(
            2,
            Some(Box::new(TreeNode::new(4))),
            Some(Box::new(TreeNode::new(5))),
        ))),
        Some(Box::new(TreeNode::new(3))),
    )));
    
    let tree_iter = TreeIterator::new(tree);
    
    println!("前序遍历:");
    for value in tree_iter {
        println!("  节点值: {}", value);
    }
    
    // 创建另一个树进行更复杂的操作
    let tree2 = Some(Box::new(TreeNode::with_children(
        10,
        Some(Box::new(TreeNode::with_children(
            5,
            Some(Box::new(TreeNode::new(3))),
            Some(Box::new(TreeNode::new(7))),
        ))),
        Some(Box::new(TreeNode::with_children(
            15,
            Some(Box::new(TreeNode::new(12))),
            Some(Box::new(TreeNode::new(18))),
        ))),
    )));
    
    let tree_iter2 = TreeIterator::new(tree2);
    
    // 使用迭代器方法
    let sum: i32 = tree_iter2.sum();
    println!("\n树中所有节点值的和: {}", sum);
    
    // 演示迭代器组合
    demonstrate_iterator_combinations();
}

fn demonstrate_iterator_combinations() {
    println!("\n迭代器组合:");
    
    // 组合多个自定义迭代器
    let counter = Counter::new(5);
    let fib = Fibonacci::new(5);
    
    // 使用zip组合
    let combined: Vec<(usize, u64)> = counter.zip(fib).collect();
    println!("计数器和斐波那契组合: {:?}", combined);
    
    // 链式组合
    let range1 = StepRange::new(1, 6, 1);
    let range2 = StepRange::new(10, 16, 1);
    
    let chained: Vec<i32> = range1.chain(range2).collect();
    println!("链式组合范围: {:?}", chained);
    
    // 复杂的迭代器操作
    let fib_large = Fibonacci::new(15);
    let result: Vec<u64> = fib_large
        .filter(|&x| x % 2 == 0)  // 偶数斐波那契数
        .map(|x| x * 2)           // 乘以2
        .take(5)                  // 取前5个
        .collect();
    
    println!("处理后的斐波那契数: {:?}", result);
}

rustc custom_iterators.rs && ./custom_iterators

6.4 闭包

6.4.1 闭包基础

fn main() {
    println!("📦 闭包基础");
    println!("===========");
    
    demonstrate_closure_syntax();
    demonstrate_closure_capture();
    demonstrate_closure_traits();
    demonstrate_closure_as_parameters();
}

fn demonstrate_closure_syntax() {
    println!("\n闭包语法:");
    
    // 基本闭包语法
    let add_one = |x| x + 1;
    println!("5 + 1 = {}", add_one(5));
    
    // 显式类型注解
    let add_two = |x: i32| -> i32 { x + 2 };
    println!("5 + 2 = {}", add_two(5));
    
    // 多参数闭包
    let multiply = |x, y| x * y;
    println!("3 * 4 = {}", multiply(3, 4));
    
    // 无参数闭包
    let get_random = || 42;
    println!("随机数: {}", get_random());
    
    // 复杂闭包体
    let complex_operation = |x: i32| {
        let doubled = x * 2;
        let squared = doubled * doubled;
        squared + 1
    };
    println!("复杂操作结果: {}", complex_operation(3));
    
    // 闭包类型推断
    let numbers = vec![1, 2, 3, 4, 5];
    
    // 编译器可以推断闭包的类型
    let doubled: Vec<i32> = numbers
        .iter()
        .map(|x| x * 2)
        .collect();
    
    println!("翻倍结果: {:?}", doubled);
    
    // 不同的闭包语法形式
    let add_one_v1 = |x: u32| -> u32 { x + 1 };
    let add_one_v2 = |x|             { x + 1 };
    let add_one_v3 = |x|               x + 1  ;
    
    println!("不同语法形式: {}, {}, {}", 
             add_one_v1(1), add_one_v2(1), add_one_v3(1));
}

fn demonstrate_closure_capture() {
    println!("\n闭包捕获:");
    
    // 捕获不可变引用
    let x = 4;
    let equal_to_x = |z| z == x;
    let y = 4;
    println!("y等于x吗？ {}", equal_to_x(y));
    
    // 捕获可变引用
    let mut count = 0;
    let mut increment = || {
        count += 1;
        println!("计数: {}", count);
    };
    
    increment();
    increment();
    increment();
    
    // 获取所有权
    let name = String::from("Alice");
    let greet = move || {
        println!("Hello, {}!", name);
    };
    
    greet();
    // name在这里不能再使用，因为被move了
    
    // 演示不同的捕获方式
    demonstrate_capture_modes();
}

fn demonstrate_capture_modes() {
    println!("\n捕获模式:");
    
    // FnOnce - 获取所有权
    let consume_with_relish = |food: String| {
        println!("美味地吃掉: {}", food);
    };
    
    let food = String::from("苹果");
    consume_with_relish(food);
    // food不能再使用
    
    // Fn - 不可变借用
    let x = vec![1, 2, 3];
    let print_vec = || {
        println!("向量: {:?}", x);
    };
    
    print_vec();
    print_vec(); // 可以多次调用
    println!("x仍然可用: {:?}", x);
    
    // FnMut - 可变借用
    let mut y = vec![1, 2, 3];
    let mut modify_vec = || {
        y.push(4);
        println!("修改后的向量: {:?}", y);
    };
    
    modify_vec();
    modify_vec();
    
    // move关键字强制获取所有权
    let z = vec![1, 2, 3];
    let take_ownership = move || {
        println!("拥有的向量: {:?}", z);
    };
    
    take_ownership();
    // z不能再使用
    
    // 在线程中使用move
    let data = vec![1, 2, 3, 4, 5];
    let handle = std::thread::spawn(move || {
        println!("线程中的数据: {:?}", data);
    });
    
    handle.join().unwrap();
}

fn demonstrate_closure_traits() {
    println!("\n闭包特征:");
    
    // 演示不同特征的闭包
    let fn_closure = || println!("这是一个Fn闭包");
    let mut count = 0;
    let fn_mut_closure = || {
        count += 1;
        println!("这是一个FnMut闭包，计数: {}", count);
    };
    
    let data = String::from("数据");
    let fn_once_closure = move || {
        println!("这是一个FnOnce闭包，数据: {}", data);
    };
    
    // 调用不同类型的闭包
    call_fn(fn_closure);
    call_fn_mut(fn_mut_closure);
    call_fn_once(fn_once_closure);
    
    // 演示闭包作为返回值
    let multiplier = create_multiplier(3);
    println!("乘法器结果: {}", multiplier(10));
    
    let adder = create_adder(5);
    println!("加法器结果: {}", adder(7));
}

fn call_fn<F>(f: F) 
where 
    F: Fn(),
{
    f();
    f(); // Fn可以多次调用
}

fn call_fn_mut<F>(mut f: F) 
where 
    F: FnMut(),
{
    f();
    f(); // FnMut可以多次调用
}

fn call_fn_once<F>(f: F) 
where 
    F: FnOnce(),
{
    f(); // FnOnce只能调用一次
}

// 返回闭包
fn create_multiplier(factor: i32) -> impl Fn(i32) -> i32 {
    move |x| x * factor
}

fn create_adder(addend: i32) -> Box<dyn Fn(i32) -> i32> {
    Box::new(move |x| x + addend)
}

fn demonstrate_closure_as_parameters() {
    println!("\n闭包作为参数:");
    
    let numbers = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
    
    // 使用闭包进行过滤和映射
    let result = process_numbers(&numbers, |x| x % 2 == 0, |x| x * x);
    println!("偶数平方: {:?}", result);
    
    let result2 = process_numbers(&numbers, |x| x > 5, |x| x + 10);
    println!("大于5的数加10: {:?}", result2);
    
    // 使用闭包进行排序
    let mut words = vec!["banana", "apple", "cherry", "date"];
    sort_by(&mut words, |a, b| a.len().cmp(&b.len()));
    println!("按长度排序: {:?}", words);
    
    let mut numbers2 = vec![3, 1, 4, 1, 5, 9, 2, 6];
    sort_by(&mut numbers2, |a, b| b.cmp(a)); // 降序
    println!("降序排序: {:?}", numbers2);
    
    // 高阶函数示例
    let add_ten = create_operation(10, |a, b| a + b);
    let multiply_by_three = create_operation(3, |a, b| a * b);
    
    println!("5 + 10 = {}", add_ten(5));
    println!("5 * 3 = {}", multiply_by_three(5));
}

fn process_numbers<F, G>(numbers: &[i32], filter: F, map: G) -> Vec<i32>
where
    F: Fn(&i32) -> bool,
    G: Fn(&i32) -> i32,
{
    numbers
        .iter()
        .filter(|&x| filter(x))
        .map(|x| map(x))
        .collect()
}

fn sort_by<T, F>(slice: &mut [T], compare: F)
where
    F: Fn(&T, &T) -> std::cmp::Ordering,
{
    slice.sort_by(compare);
}

fn create_operation<F>(value: i32, op: F) -> impl Fn(i32) -> i32
where
    F: Fn(i32, i32) -> i32,
{
    move |x| op(x, value)
}

rustc closures_basics.rs && ./closures_basics

6.4.2 高级闭包应用

use std::collections::HashMap;
use std::thread;
use std::time::Duration;

fn main() {
    println!("🚀 高级闭包应用");
    println!("===============");
    
    demonstrate_memoization();
    demonstrate_lazy_evaluation();
    demonstrate_callback_patterns();
    demonstrate_functional_programming();
}

// 记忆化（缓存）模式
struct Memoizer<F, K, V>
where
    F: Fn(&K) -> V,
    K: std::hash::Hash + Eq + Clone,
    V: Clone,
{
    calculation: F,
    cache: std::cell::RefCell<HashMap<K, V>>,
}

impl<F, K, V> Memoizer<F, K, V>
where
    F: Fn(&K) -> V,
    K: std::hash::Hash + Eq + Clone,
    V: Clone,
{
    fn new(calculation: F) -> Self {
        Memoizer {
            calculation,
            cache: std::cell::RefCell::new(HashMap::new()),
        }
    }
    
    fn call(&self, key: K) -> V {
        let mut cache = self.cache.borrow_mut();
        
        if let Some(cached_value) = cache.get(&key) {
            println!("缓存命中: {:?}", key);
            cached_value.clone()
        } else {
            println!("计算新值: {:?}", key);
            let value = (self.calculation)(&key);
            cache.insert(key, value.clone());
            value
        }
    }
}

fn demonstrate_memoization() {
    println!("\n记忆化模式:");
    
    // 昂贵的斐波那契计算
    let fib_calculator = Memoizer::new(|&n: &u32| -> u64 {
        if n <= 1 {
            n as u64
        } else {
            // 模拟昂贵的计算
            thread::sleep(Duration::from_millis(100));
            fibonacci_recursive(n)
        }
    });
    
    println!("计算斐波那契数列:");
    for i in [10, 5, 10, 8, 5, 12] {
        let start = std::time::Instant::now();
        let result = fib_calculator.call(i);
        let duration = start.elapsed();
        println!("fib({}) = {}, 耗时: {:?}", i, result, duration);
    }
    
    // 字符串处理的记忆化
    let string_processor = Memoizer::new(|text: &String| -> String {
        println!("处理字符串: {}", text);
        thread::sleep(Duration::from_millis(50));
        text.to_uppercase().chars().rev().collect()
    });
    
    let texts = vec![
        "hello".to_string(),
        "world".to_string(),
        "hello".to_string(), // 应该使用缓存
        "rust".to_string(),
        "world".to_string(), // 应该使用缓存
    ];
    
    println!("\n字符串处理:");
    for text in texts {
        let result = string_processor.call(text.clone());
        println!("{} -> {}", text, result);
    }
}

fn fibonacci_recursive(n: u32) -> u64 {
    if n <= 1 {
        n as u64
    } else {
        fibonacci_recursive(n - 1) + fibonacci_recursive(n - 2)
    }
}

// 惰性求值
struct LazyValue<F, T>
where
    F: FnOnce() -> T,
{
    calculation: Option<F>,
    value: Option<T>,
}

impl<F, T> LazyValue<F, T>
where
    F: FnOnce() -> T,
{
    fn new(calculation: F) -> Self {
        LazyValue {
            calculation: Some(calculation),
            value: None,
        }
    }
    
    fn get(&mut self) -> &T {
        if self.value.is_none() {
            let calculation = self.calculation.take().unwrap();
            self.value = Some(calculation());
        }
        self.value.as_ref().unwrap()
    }
}

fn demonstrate_lazy_evaluation() {
    println!("\n惰性求值:");
    
    let mut expensive_calculation = LazyValue::new(|| {
        println!("执行昂贵的计算...");
        thread::sleep(Duration::from_millis(100));
        42 * 42
    });
    
    println!("创建了惰性值，但还没有计算");
    
    // 第一次访问时才计算
    println!("第一次访问: {}", expensive_calculation.get());
    
    // 后续访问使用缓存的值
    println!("第二次访问: {}", expensive_calculation.get());
    println!("第三次访问: {}", expensive_calculation.get());
    
    // 惰性列表处理
    let numbers = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
    
    let lazy_operations = numbers
        .iter()
        .map(|&x| {
            LazyValue::new(move || {
                println!("处理数字: {}", x);
                x * x * x // 立方
            })
        })
        .collect::<Vec<_>>();
    
    println!("\n创建了惰性操作列表");
    
    // 只计算前3个
    println!("只计算前3个:");
    for (i, mut lazy_op) in lazy_operations.into_iter().take(3).enumerate() {
        println!("结果 {}: {}", i, lazy_op.get());
    }
}

// 回调模式
struct EventEmitter<T> {
    listeners: Vec<Box<dyn Fn(&T)>>,
}

impl<T> EventEmitter<T> {
    fn new() -> Self {
        EventEmitter {
            listeners: Vec::new(),
        }
    }
    
    fn on<F>(&mut self, listener: F)
    where
        F: Fn(&T) + 'static,
    {
        self.listeners.push(Box::new(listener));
    }
    
    fn emit(&self, event: &T) {
        for listener in &self.listeners {
            listener(event);
        }
    }
}

#[derive(Debug, Clone)]
struct UserEvent {
    user_id: u32,
    action: String,
    timestamp: u64,
}

fn demonstrate_callback_patterns() {
    println!("\n回调模式:");
    
    let mut event_emitter = EventEmitter::new();
    
    // 注册多个事件监听器
    event_emitter.on(|event: &UserEvent| {
        println!("日志记录: 用户 {} 执行了 {}", event.user_id, event.action);
    });
    
    event_emitter.on(|event: &UserEvent| {
        if event.action == "login" {
            println!("安全检查: 用户 {} 登录", event.user_id);
        }
    });
    
    event_emitter.on(|event: &UserEvent| {
        println!("统计: 记录用户 {} 的活动", event.user_id);
    });
    
    // 触发事件
    let events = vec![
        UserEvent {
            user_id: 1,
            action: "login".to_string(),
            timestamp: 1234567890,
        },
        UserEvent {
            user_id: 1,
            action: "view_page".to_string(),
            timestamp: 1234567891,
        },
        UserEvent {
            user_id: 2,
            action: "login".to_string(),
            timestamp: 1234567892,
        },
    ];
    
    for event in &events {
        println!("\n触发事件: {:?}", event);
        event_emitter.emit(event);
    }
    
    // 链式回调
    demonstrate_chained_callbacks();
}

fn demonstrate_chained_callbacks() {
    println!("\n链式回调:");
    
    // 模拟异步操作的链式调用
    let process_data = |data: i32, callback: Box<dyn Fn(i32)>| {
        println!("处理数据: {}", data);
        let result = data * 2;
        callback(result);
    };
    
    let validate_data = |data: i32, callback: Box<dyn Fn(i32)>| {
        println!("验证数据: {}", data);
        if data > 0 {
            callback(data);
        } else {
            println!("数据验证失败");
        }
    };
    
    let save_data = |data: i32| {
        println!("保存数据: {}", data);
    };
    
    // 链式调用
    validate_data(5, Box::new(|validated_data| {
        process_data(validated_data, Box::new(|processed_data| {
            save_data(processed_data);
        }));
    }));
}

fn demonstrate_functional_programming() {
    println!("\n函数式编程模式:");
    
    // 函数组合
    let add_one = |x: i32| x + 1;
    let multiply_by_two = |x: i32| x * 2;
    let square = |x: i32| x * x;
    
    // 组合函数
    let composed = compose(compose(add_one, multiply_by_two), square);
    
    println!("组合函数结果: {}", composed(3)); // ((3 + 1) * 2)^2 = 64
    
    // 柯里化
    let add = |x: i32| move |y: i32| x + y;
    let add_five = add(5);
    
    println!("柯里化结果: {}", add_five(10)); // 15
    
    // 高阶函数应用
    let numbers = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
    
    // 使用闭包进行复杂的数据处理
    let result = numbers
        .iter()
        .filter(|&&x| x % 2 == 0)           // 过滤偶数
        .map(|&x| x * x)                    // 平方
        .filter(|&x| x > 10)                // 过滤大于10的
        .fold(0, |acc, x| acc + x);         // 求和
    
    println!("函数式处理结果: {}", result);
    
    // 使用闭包实现策略模式
    demonstrate_strategy_pattern();
}

fn compose<F, G, A, B, C>(f: F, g: G) -> impl Fn(A) -> C
where
    F: Fn(A) -> B,
    G: Fn(B) -> C,
{
    move |x| g(f(x))
}

fn demonstrate_strategy_pattern() {
    println!("\n策略模式:");
    
    // 不同的排序策略
    let mut numbers = vec![64, 34, 25, 12, 22, 11, 90];
    
    // 升序策略
    let ascending = |a: &i32, b: &i32| a.cmp(b);
    
    // 降序策略
    let descending = |a: &i32, b: &i32| b.cmp(a);
    
    // 按绝对值排序策略
    let by_abs = |a: &i32, b: &i32| a.abs().cmp(&b.abs());
    
    println!("原始数组: {:?}", numbers);
    
    // 使用不同策略排序
    let mut temp = numbers.clone();
    temp.sort_by(ascending);
    println!("升序排序: {:?}", temp);
    
    let mut temp = numbers.clone();
    temp.sort_by(descending);
    println!("降序排序: {:?}", temp);
    
    let mut temp = vec![-5, 3, -1, 4, -2];
    temp.sort_by(by_abs);
    println!("按绝对值排序: {:?}", temp);
    
    // 计算策略
    let calculate = |numbers: &[i32], strategy: Box<dyn Fn(&[i32]) -> i32>| {
        strategy(numbers)
    };
    
    let sum_strategy = Box::new(|nums: &[i32]| nums.iter().sum());
    let product_strategy = Box::new(|nums: &[i32]| nums.iter().product());
    let max_strategy = Box::new(|nums: &[i32]| *nums.iter().max().unwrap_or(&0));
    
    let test_numbers = vec![1, 2, 3, 4, 5];
    
    println!("\n计算策略:");
    println!("数组: {:?}", test_numbers);
    println!("求和: {}", calculate(&test_numbers, sum_strategy));
    println!("求积: {}", calculate(&test_numbers, product_strategy));
    println!("最大值: {}", calculate(&test_numbers, max_strategy));
}

rustc advanced_closures.rs && ./advanced_closures

6.5 错误处理控制流

6.5.1 Result和Option的控制流

use std::fs::File;
use std::io::{self, Read};
use std::num::ParseIntError;

fn main() {
    println!("🛡️ 错误处理控制流");
    println!("=================");
    
    demonstrate_option_control_flow();
    demonstrate_result_control_flow();
    demonstrate_error_propagation();
    demonstrate_error_recovery();
}

fn demonstrate_option_control_flow() {
    println!("\nOption控制流:");
    
    let numbers = vec!["1", "2", "not_a_number", "4", "5"];
    
    // 使用if let处理Option
    for num_str in &numbers {
        if let Ok(num) = num_str.parse::<i32>() {
            println!("解析成功: {} -> {}", num_str, num);
        } else {
            println!("解析失败: {}", num_str);
        }
    }
    
    // 使用match处理Option
    let maybe_number = Some(42);
    match maybe_number {
        Some(n) if n > 40 => println!("大数字: {}", n),
        Some(n) => println!("小数字: {}", n),
        None => println!("没有数字"),
    }
    
    // 使用map和filter处理Option序列
    let options = vec![Some(1), None, Some(3), Some(4), None, Some(6)];
    
    let processed: Vec<i32> = options
        .iter()
        .filter_map(|&opt| opt)  // 过滤掉None，提取Some中的值
        .map(|x| x * 2)          // 处理值
        .filter(|&x| x > 4)      // 过滤结果
        .collect();
    
    println!("处理后的Option序列: {:?}", processed);
    
    // 使用and_then进行链式操作
    let result = Some("42")
        .and_then(|s| s.parse::<i32>().ok())
        .and_then(|n| if n > 0 { Some(n * 2) } else { None })
        .and_then(|n| if n < 100 { Some(n) } else { None });
    
    println!("链式Option操作结果: {:?}", result);
    
    // 使用or_else提供备选方案
    let primary = None;
    let secondary = Some("备选值");
    
    let final_value = primary
        .or_else(|| secondary)
        .or_else(|| Some("默认值"));
    
    println!("备选方案结果: {:?}", final_value);
}

fn demonstrate_result_control_flow() {
    println!("\nResult控制流:");
    
    // 基本Result处理
    let division_results = vec![
        divide(10, 2),
        divide(10, 0),
        divide(8, 4),
        divide(15, 0),
    ];
    
    for (i, result) in division_results.iter().enumerate() {
        match result {
            Ok(value) => println!("除法 {} 成功: {}", i, value),
            Err(e) => println!("除法 {} 失败: {}", i, e),
        }
    }
    
    // 使用map和map_err转换Result
    let number_str = "42";
    let result = number_str
        .parse::<i32>()
        .map(|n| n * 2)  // 成功时转换值
        .map_err(|e| format!("解析错误: {}", e));  // 失败时转换错误
    
    println!("转换后的Result: {:?}", result);
    
    // 使用and_then进行可能失败的链式操作
    let chain_result = "100"
        .parse::<i32>()
        .and_then(|n| divide(n, 2))
        .and_then(|n| divide(n, 5))
        .and_then(|n| if n > 0 { Ok(n) } else { Err("结果不是正数".to_string()) });
    
    println!("链式Result操作: {:?}", chain_result);
    
    // 使用or_else进行错误恢复
    let recovery_result = divide(10, 0)
        .or_else(|_| {
            println!("第一次尝试失败，尝试备选方案");
            divide(10, 2)
        })
        .or_else(|_| {
            println!("第二次尝试失败，使用默认值");
            Ok(1)
        });
    
    println!("错误恢复结果: {:?}", recovery_result);
}

fn divide(a: i32, b: i32) -> Result<i32, String> {
    if b == 0 {
        Err("除零错误".to_string())
    } else {
        Ok(a / b)
    }
}

fn demonstrate_error_propagation() {
    println!("\n错误传播:");
    
    // 使用?操作符进行错误传播
    match read_and_parse_file("numbers.txt") {
        Ok(numbers) => println!("成功读取数字: {:?}", numbers),
        Err(e) => println!("操作失败: {}", e),
    }
    
    // 创建测试文件
    std::fs::write("test_numbers.txt", "1\n2\n3\n4\n5").unwrap();
    
    match read_and_parse_file("test_numbers.txt") {
        Ok(numbers) => {
            println!("成功读取数字: {:?}", numbers);
            let sum: i32 = numbers.iter().sum();
            println!("数字总和: {}", sum);
        }
        Err(e) => println!("操作失败: {}", e),
    }
    
    // 清理测试文件
    let _ = std::fs::remove_file("test_numbers.txt");
    
    // 复杂的错误传播链
    match complex_operation("42") {
        Ok(result) => println!("复杂操作成功: {}", result),
        Err(e) => println!("复杂操作失败: {}", e),
    }
    
    match complex_operation("not_a_number") {
        Ok(result) => println!("复杂操作成功: {}", result),
        Err(e) => println!("复杂操作失败: {}", e),
    }
}

#[derive(Debug)]
enum MyError {
    Io(io::Error),
    Parse(ParseIntError),
    Custom(String),
}

impl From<io::Error> for MyError {
    fn from(error: io::Error) -> Self {
        MyError::Io(error)
    }
}

impl From<ParseIntError> for MyError {
    fn from(error: ParseIntError) -> Self {
        MyError::Parse(error)
    }
}

impl std::fmt::Display for MyError {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        match self {
            MyError::Io(e) => write!(f, "IO错误: {}", e),
            MyError::Parse(e) => write!(f, "解析错误: {}", e),
            MyError::Custom(msg) => write!(f, "自定义错误: {}", msg),
        }
    }
}

fn read_and_parse_file(filename: &str) -> Result<Vec<i32>, MyError> {
    let mut file = File::open(filename)?;
    let mut contents = String::new();
    file.read_to_string(&mut contents)?;
    
    let numbers: Result<Vec<i32>, _> = contents
        .lines()
        .map(|line| line.trim().parse::<i32>())
        .collect();
    
    Ok(numbers?)
}

fn complex_operation(input: &str) -> Result<i32, MyError> {
    let number = input.parse::<i32>()?;
    
    if number < 0 {
        return Err(MyError::Custom("数字不能为负数".to_string()));
    }
    
    let doubled = number * 2;
    
    if doubled > 1000 {
        return Err(MyError::Custom("结果太大".to_string()));
    }
    
    Ok(doubled)
}

fn demonstrate_error_recovery() {
    println!("\n错误恢复策略:");
    
    // 重试机制
    let result = retry_operation(3, || {
        static mut ATTEMPT: i32 = 0;
        unsafe {
            ATTEMPT += 1;
            if ATTEMPT < 3 {
                Err(format!("尝试 {} 失败", ATTEMPT))
            } else {
                Ok("成功!")
            }
        }
    });
    
    match result {
        Ok(value) => println!("重试成功: {}", value),
        Err(e) => println!("重试失败: {}", e),
    }
    
    // 降级处理
    let services = vec!["primary", "secondary", "fallback"];
    
    for service in &services {
        match call_service(service) {
            Ok(response) => {
                println!("服务 {} 响应: {}", service, response);
                break;
            }
            Err(e) => {
                println!("服务 {} 失败: {}, 尝试下一个", service, e);
                continue;
            }
        }
    }
    
    // 部分成功处理
    let inputs = vec!["1", "2", "invalid", "4", "5"];
    let (successes, failures): (Vec<_>, Vec<_>) = inputs
        .iter()
        .map(|&s| s.parse::<i32>())
        .partition(Result::is_ok);
    
    let successes: Vec<i32> = successes.into_iter().map(Result::unwrap).collect();
    let failures: Vec<_> = failures.into_iter().map(Result::unwrap_err).collect();
    
    println!("\n部分成功处理:");
    println!("成功: {:?}", successes);
    println!("失败: {} 个", failures.len());
    
    // 累积错误
    let results = vec![
        Ok(1),
        Err("错误1".to_string()),
        Ok(2),
        Err("错误2".to_string()),
        Ok(3),
    ];
    
    let (values, errors): (Vec<_>, Vec<_>) = results
        .into_iter()
        .partition(Result::is_ok);
    
    let values: Vec<i32> = values.into_iter().map(Result::unwrap).collect();
    let errors: Vec<String> = errors.into_iter().map(Result::unwrap_err).collect();
    
    println!("\n累积结果:");
    println!("值: {:?}", values);
    println!("错误: {:?}", errors);
}

fn retry_operation<F, T, E>(max_attempts: usize, mut operation: F) -> Result<T, E>
where
    F: FnMut() -> Result<T, E>,
{
    let mut attempts = 0;
    
    loop {
        attempts += 1;
        
        match operation() {
            Ok(result) => return Ok(result),
            Err(e) => {
                if attempts >= max_attempts {
                    return Err(e);
                }
                println!("尝试 {} 失败，重试中...", attempts);
            }
        }
    }
}

fn call_service(service: &str) -> Result<String, String> {
    match service {
        "primary" => Err("主服务不可用".to_string()),
        "secondary" => Err("备用服务不可用".to_string()),
        "fallback" => Ok("降级服务响应".to_string()),
        _ => Err("未知服务".to_string()),
    }
}

rustc error_control_flow.rs && ./error_control_flow

6.6 综合示例：状态机

use std::collections::HashMap;
use std::fmt;

fn main() {
    println!("🤖 状态机示例");
    println!("============");
    
    demonstrate_traffic_light();
    demonstrate_order_processing();
    demonstrate_game_state();
}

// 交通灯状态机
#[derive(Debug, Clone, PartialEq)]
enum TrafficLightState {
    Red,
    Yellow,
    Green,
}

impl TrafficLightState {
    fn next(&self) -> Self {
        match self {
            TrafficLightState::Red => TrafficLightState::Green,
            TrafficLightState::Green => TrafficLightState::Yellow,
            TrafficLightState::Yellow => TrafficLightState::Red,
        }
    }
    
    fn duration(&self) -> u32 {
        match self {
            TrafficLightState::Red => 30,
            TrafficLightState::Yellow => 5,
            TrafficLightState::Green => 25,
        }
    }
}

impl fmt::Display for TrafficLightState {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            TrafficLightState::Red => write!(f, "🔴 红灯"),
            TrafficLightState::Yellow => write!(f, "🟡 黄灯"),
            TrafficLightState::Green => write!(f, "🟢 绿灯"),
        }
    }
}

struct TrafficLight {
    state: TrafficLightState,
    remaining_time: u32,
}

impl TrafficLight {
    fn new() -> Self {
        TrafficLight {
            state: TrafficLightState::Red,
            remaining_time: TrafficLightState::Red.duration(),
        }
    }
    
    fn tick(&mut self) {
        if self.remaining_time > 0 {
            self.remaining_time -= 1;
        } else {
            self.state = self.state.next();
            self.remaining_time = self.state.duration();
        }
    }
    
    fn status(&self) -> String {
        format!("{} (剩余: {}秒)", self.state, self.remaining_time)
    }
}

fn demonstrate_traffic_light() {
    println!("\n交通灯状态机:");
    
    let mut traffic_light = TrafficLight::new();
    
    // 模拟60秒的运行
    for second in 1..=60 {
        println!("第{}秒: {}", second, traffic_light.status());
        traffic_light.tick();
        
        // 每10秒显示一次分隔线
        if second % 10 == 0 {
            println!("----------");
        }
    }
}

// 订单处理状态机
#[derive(Debug, Clone, PartialEq)]
enum OrderState {
    Pending,
    Confirmed,
    Processing,
    Shipped,
    Delivered,
    Cancelled,
}

#[derive(Debug, Clone)]
enum OrderEvent {
    Confirm,
    StartProcessing,
    Ship,
    Deliver,
    Cancel,
}

#[derive(Debug)]
struct OrderStateMachine {
    state: OrderState,
    transitions: HashMap<(OrderState, OrderEvent), OrderState>,
}

impl OrderStateMachine {
    fn new() -> Self {
        let mut transitions = HashMap::new();
        
        // 定义状态转换规则
        transitions.insert((OrderState::Pending, OrderEvent::Confirm), OrderState::Confirmed);
        transitions.insert((OrderState::Pending, OrderEvent::Cancel), OrderState::Cancelled);
        
        transitions.insert((OrderState::Confirmed, OrderEvent::StartProcessing), OrderState::Processing);
        transitions.insert((OrderState::Confirmed, OrderEvent::Cancel), OrderState::Cancelled);
        
        transitions.insert((OrderState::Processing, OrderEvent::Ship), OrderState::Shipped);
        transitions.insert((OrderState::Processing, OrderEvent::Cancel), OrderState::Cancelled);
        
        transitions.insert((OrderState::Shipped, OrderEvent::Deliver), OrderState::Delivered);
        
        OrderStateMachine {
            state: OrderState::Pending,
            transitions,
        }
    }
    
    fn handle_event(&mut self, event: OrderEvent) -> Result<(), String> {
        let key = (self.state.clone(), event.clone());
        
        if let Some(new_state) = self.transitions.get(&key) {
            println!("状态转换: {:?} --{:?}--> {:?}", self.state, event, new_state);
            self.state = new_state.clone();
            Ok(())
        } else {
            Err(format!("无效的状态转换: {:?} 在状态 {:?}", event, self.state))
        }
    }
    
    fn current_state(&self) -> &OrderState {
        &self.state
    }
    
    fn can_handle(&self, event: &OrderEvent) -> bool {
        self.transitions.contains_key(&(self.state.clone(), event.clone()))
    }
}

fn demonstrate_order_processing() {
    println!("\n订单处理状态机:");
    
    let mut order = OrderStateMachine::new();
    
    let events = vec![
        OrderEvent::Confirm,
        OrderEvent::StartProcessing,
        OrderEvent::Ship,
        OrderEvent::Deliver,
    ];
    
    println!("初始状态: {:?}", order.current_state());
    
    for event in events {
        match order.handle_event(event.clone()) {
            Ok(()) => println!("当前状态: {:?}", order.current_state()),
            Err(e) => println!("错误: {}", e),
        }
    }
    
    // 测试无效转换
    println!("\n测试无效转换:");
    let invalid_events = vec![
        OrderEvent::StartProcessing, // 已经是Delivered状态
        OrderEvent::Cancel,          // 无法取消已交付的订单
    ];
    
    for event in invalid_events {
        if order.can_handle(&event) {
            let _ = order.handle_event(event);
        } else {
            println!("无法在状态 {:?} 下处理事件 {:?}", order.current_state(), event);
        }
    }
    
    // 演示取消流程
    println!("\n演示取消流程:");
    let mut order2 = OrderStateMachine::new();
    
    let _ = order2.handle_event(OrderEvent::Confirm);
    let _ = order2.handle_event(OrderEvent::Cancel);
    
    println!("最终状态: {:?}", order2.current_state());
}

// 游戏状态机
#[derive(Debug, Clone, PartialEq)]
enum GameState {
    Menu,
    Playing,
    Paused,
    GameOver,
    Victory,
}

#[derive(Debug, Clone)]
enum GameEvent {
    StartGame,
    PauseGame,
    ResumeGame,
    PlayerDied,
    PlayerWon,
    RestartGame,
    QuitToMenu,
}

struct GameStateMachine {
    state: GameState,
    score: u32,
    lives: u32,
}

impl GameStateMachine {
    fn new() -> Self {
        GameStateMachine {
            state: GameState::Menu,
            score: 0,
            lives: 3,
        }
    }
    
    fn handle_event(&mut self, event: GameEvent) -> Result<String, String> {
        let old_state = self.state.clone();
        
        match (&self.state, &event) {
            (GameState::Menu, GameEvent::StartGame) => {
                self.state = GameState::Playing;
                self.score = 0;
                self.lives = 3;
                Ok("游戏开始！".to_string())
            }
            
            (GameState::Playing, GameEvent::PauseGame) => {
                self.state = GameState::Paused;
                Ok("游戏暂停".to_string())
            }
            
            (GameState::Paused, GameEvent::ResumeGame) => {
                self.state = GameState::Playing;
                Ok("游戏继续".to_string())
            }
            
            (GameState::Playing, GameEvent::PlayerDied) => {
                self.lives -= 1;
                if self.lives == 0 {
                    self.state = GameState::GameOver;
                    Ok(format!("游戏结束！最终得分: {}", self.score))
                } else {
                    Ok(format!("玩家死亡！剩余生命: {}", self.lives))
                }
            }
            
            (GameState::Playing, GameEvent::PlayerWon) => {
                self.state = GameState::Victory;
                Ok(format!("胜利！最终得分: {}", self.score))
            }
            
            (GameState::GameOver | GameState::Victory, GameEvent::RestartGame) => {
                self.state = GameState::Playing;
                self.score = 0;
                self.lives = 3;
                Ok("重新开始游戏".to_string())
            }
            
            (_, GameEvent::QuitToMenu) => {
                self.state = GameState::Menu;
                Ok("返回主菜单".to_string())
            }
            
            _ => Err(format!("无效的事件 {:?} 在状态 {:?}", event, old_state)),
        }
    }
    
    fn add_score(&mut self, points: u32) {
        if self.state == GameState::Playing {
            self.score += points;
        }
    }
    
    fn status(&self) -> String {
        match self.state {
            GameState::Menu => "主菜单".to_string(),
            GameState::Playing => format!("游戏中 - 得分: {}, 生命: {}", self.score, self.lives),
            GameState::Paused => format!("暂停中 - 得分: {}, 生命: {}", self.score, self.lives),
            GameState::GameOver => format!("游戏结束 - 最终得分: {}", self.score),
            GameState::Victory => format!("胜利！ - 最终得分: {}", self.score),
        }
    }
}

fn demonstrate_game_state() {
    println!("\n游戏状态机:");
    
    let mut game = GameStateMachine::new();
    
    println!("初始状态: {}", game.status());
    
    // 模拟游戏流程
    let game_flow = vec![
        (GameEvent::StartGame, "开始游戏"),
        (GameEvent::PauseGame, "暂停游戏"),
        (GameEvent::ResumeGame, "继续游戏"),
        (GameEvent::PlayerDied, "玩家死亡"),
        (GameEvent::PlayerDied, "玩家再次死亡"),
        (GameEvent::PlayerWon, "玩家胜利"),
        (GameEvent::RestartGame, "重新开始"),
        (GameEvent::QuitToMenu, "退出到菜单"),
    ];
    
    for (event, description) in game_flow {
        println!("\n执行: {}", description);
        
        // 在游戏中时增加一些分数
        if game.state == GameState::Playing {
            game.add_score(100);
        }
        
        match game.handle_event(event) {
            Ok(message) => {
                println!("结果: {}", message);
                println!("状态: {}", game.status());
            }
            Err(error) => {
                println!("错误: {}", error);
            }
        }
    }
    
    // 演示复杂的游戏场景
    println!("\n复杂游戏场景:");
    let mut game2 = GameStateMachine::new();
    
    let _ = game2.handle_event(GameEvent::StartGame);
    
    // 模拟游戏过程
    for round in 1..=5 {
        game2.add_score(round * 50);
        println!("第{}轮: {}", round, game2.status());
        
        if round == 3 {
            let _ = game2.handle_event(GameEvent::PlayerDied);
            println!("玩家在第3轮死亡: {}", game2.status());
        }
    }
    
    // 最终胜利
    match game2.handle_event(GameEvent::PlayerWon) {
        Ok(message) => println!("\n{}", message),
        Err(e) => println!("错误: {}", e),
    }
}

rustc state_machine.rs && ./state_machine

本章小结

通过本章学习，你应该掌握了：

✅ 条件语句: if表达式、match模式匹配、守卫条件 ✅ 循环结构: loop、while、for循环及其控制 ✅ 迭代器: 创建、适配器、消费者、自定义迭代器 ✅ 闭包: 语法、捕获模式、特征、高级应用 ✅ 错误处理: Option/Result控制流、错误传播、恢复策略 ✅ 状态机: 设计模式、状态转换、事件处理

下一章预告

在下一章《模块系统》中，我们将学习：

• 模块定义和组织
• 可见性和访问控制
• 包和Crate管理
• 外部依赖使用
• 项目结构最佳实践

练习题

练习1：计算器状态机

实现一个计算器状态机，支持基本的四则运算和状态管理。

练习2：自定义迭代器

创建一个素数迭代器，能够生成指定范围内的所有素数。

练习3：错误处理链

设计一个文件处理系统，包含完整的错误处理和恢复机制。

练习4：函数式数据处理

使用闭包和迭代器实现一个数据分析工具，支持过滤、映射、聚合等操作。

---

恭喜你掌握了Rust的控制流！ 🎉

控制流是程序逻辑的核心，Rust的控制流结构既强大又安全。配合所有权系统和类型系统，你可以编写出既高效又可靠的程序。现在让我们继续学习模块系统！