rust for循环与闭包

June 22, 2023

for 区间

注意：区间的类型是 core::ops::range::Range 泛型结构

rust

fn main() {
    for n in 1..5 {
        println!("{}", n);
    }
    for n in 5..=10 {
        println!("{}", n);
    }
}

三种迭代形式

参见：std::iter

有三种常见的方法可以从集合中创建迭代器：

iter()，它在 &T 上迭代。
iter_mut()，它在 &mut T 上迭代。
into_iter()，它在 T 上迭代。

rust

fn main() {
    let names = vec!["Bob", "Frank", "Ferris"];

    // 不可变借用
    for name in names.iter() {
        match name {
            &"Ferris" => println!("There is a rustacean among us!"),
            _ => println!("Hello {}", name),
        }
    }

    // 获取所有权，这*消耗*了集合，因为集合自身不再拥有其元素的所有权
    for name in names.into_iter() {
        match name {
            "Ferris" => println!("There is a rustacean among us!"),
            _ => println!("Hello {}", name),
        }
    }

    // 变量遮蔽
    let mut names = vec!["Bob", "Frank", "Ferris"];

    // 可变借用
    for name in names.iter_mut() {
        *name = match name {
            &mut "Ferris" => "There is a rustacean among us!",
            _ => "Hello",
        }
    }
    println!("names: {:?}", names);
}

闭包捕获

`Fn`：捕获方式为通过引用（`&T`）的闭包

rust

fn type_of<T>(_: &T) -> &str {
    std::any::type_name::<T>().into()
}

fn main() {
    let color = String::from("green");

    // 闭包*不可变借用*了 `color` 变量（因为闭包本身是不可变类型）
    // 备注：`println!` 宏是通过引用使用的，不可变借用
    let print = || println!("color={} type={}", color, type_of(&color));
    print();

    // `color` 变量可再次被不可变借用，因为闭包只持有一个指向 `color` 的不可变引用。
    let _reborrow = &color;
    print();

    // 在最后使用 `print` 之后，移动或重新借用都是允许的。
    let _color_moved = color;
    // print(); 不允许使用 print，因为其捕获的变量已移动
}

`FnMut`：捕获方式为通过可变引用（`&mut T`）的闭包

rust

fn main() {
    let mut count = 0;
    // `inc` 前面需要加上 `mut`，因为闭包里存储着一个 `&mut` 可变借用的变量。
    // 调用闭包时，该变量的变化就意味着闭包内部发生了变化。因此闭包需要是可变的。
    let mut inc = || {
        count += 1;
        println!("`count`: {}", count);
    };

    // 使用可变借用调用闭包
    inc();

    // `count` 变量已经被闭包可变借用，因此*在最后一次使用闭包之前*不能再次被可变借用。
    // 故以下语句不被允许：
    // let _reborrow = &count;
    // inc();

    // 现在，闭包不再可变借用 `&mut count`，因此可以正确地重新借用
    let _count_reborrowed = &mut count;
}

`FnOnce`：捕获方式为通过值（`T`）的闭包

rust

fn type_of<T>(_: &T) -> &str {
    std::any::type_name::<T>().into()
}

fn main() {
    // 不可复制类型（non-copy type）。
    let movable = Box::new(3);

    // `std::mem::drop` 要求 `T` 类型本身，所以闭包将会*捕获变量的值*。
    // 这种情况下，可复制类型将会复制给闭包，从而原始值不受影响。
    // 不可复制类型必须移动（move）到闭包中，因而 `movable` 变量在这里立即移动到了闭包中。
    let consume = || {
        println!("movable={:?} type={}", movable, type_of(&movable));
        std::mem::drop(movable);
    };

    // `consume` 消耗了该变量，所以该闭包只能调用一次。
    consume();
    // 不能再次调用闭包：
    //consume();
}

通过指定 move 可以强制使闭包获取其捕获的变量的所有权
即，被捕获的变量的所有权被移动进了闭包

rust

fn main() {
    // `Vec` 在语义上是不可复制的。
    let haystack = vec![1, 2, 3];

    let contains = move |needle| haystack.contains(needle);

    println!("{}", contains(&1));
    println!("{}", contains(&4));

    //println!("There're {} elements in vec", haystack.len());
    // ^ 取消上面一行的注释将导致编译时错误，因为借用检查不允许在变量被移动走之后继续使用它。

    // 在闭包的签名中删除 `move` 会导致闭包以不可变方式借用 `haystack`，
    // 因此之后 `haystack` 仍然可用，取消上面的注释也不会导致错误。
}

闭包 trait

当闭包被定义，编译器会隐式地创建一个匿名类型的结构体，用以储存闭包捕获的变量，同时为这个未知类型的结构体实现函数功能，通过 Fn、FnMut 或 FnOnce 三种 trait 中的一种。

rust

fn test_closure_trait<F>(f: F) -> bool
where
    F: FnOnce(i32, f64, &str) -> bool,
{
    // ^ 试一试：将 `FnOnce` 换成 `Fn` 或 `FnMut`。

    f(1, 1.0, "1")
}

rust

fn create_fn() -> impl Fn() {
    let text: String = "Fn".to_owned();

    // 闭包作为返回值，必须指明 move，将变量所有权移动进闭包
    // 因为通过引用捕获的函数局部变量将在函数退栈后被丢弃（drop）
    move || println!("This is a: {}", text)
}

例子参见：std 中的例子

←Back to home