FnMut Trait 可变借用 ​

核心概念 ​

FnMut 是三个闭包 trait 中的中间层,表示闭包需要对捕获的变量进行可变借用(&mut T)。实现了 FnMut 的闭包可以被多次调用,每次调用都可能修改其内部状态。调用 FnMut 闭包时需要通过 &mut self,所以持有闭包的变量必须声明为 mut。FnMut 是 FnOnce 的子 trait,实现了 FnMut 的闭包自动实现 FnOnce,但不一定实现 Fn。

rust
fn main() {
    let mut count = 0;

    // 这个闭包修改了捕获的 count,实现 FnMut
    let mut increment = || {
        count += 1;
        println!("计数: {}", count);
    };

    // FnMut 闭包可以多次调用
    increment();  // 计数: 1
    increment();  // 计数: 2
    increment();  // 计数: 3

    // 闭包不再使用后,count 恢复可用
    println!("最终计数: {}", count);  // 3
}

FnMut 的调用方式 ​

rust
// FnMut 通过 &mut self 调用
// 持有闭包的变量和函数参数都需要 mut

// 参数需要 mut
fn call_twice(mut f: impl FnMut()) {
    f();
    f();
}

// 引用参数需要 &mut
fn call_with_ref(f: &mut dyn FnMut()) {
    f();
    f();
}

fn main() {
    let mut total = 0;

    // 变量必须声明为 mut
    let mut adder = || {
        total += 10;
    };

    // 传给需要 FnMut 的函数
    call_with_ref(&mut adder);
    println!("total = {}", total);  // 20

    // 注意:call_twice 接受所有权
    let mut counter = 0;
    call_twice(|| {
        counter += 1;
        println!("counter = {}", counter);
    });
}

Fn、FnMut、FnOnce 的区别 ​

rust
fn main() {
    let value = 42;
    let mut list = Vec::new();
    let data = String::from("hello");

    // Fn:只读捕获
    let read_only = || println!("value = {}", value);
    read_only();
    read_only();

    // FnMut:可变捕获
    let mut mutator = || {
        list.push(value);  // 可变借用 list,不可变借用 value
    };
    mutator();
    mutator();
    println!("list = {:?}", list);

    // FnOnce:消耗捕获
    let consumer = || {
        drop(data);  // 消耗 data
    };
    consumer();
    // consumer();  // 编译错误:FnOnce 只能调用一次
}
场景闭包行为实现的 Trait
只读取变量println!("{}", x)Fn + FnMut + FnOnce
修改变量x += 1FnMut + FnOnce
消耗变量drop(x)FnOnce
调用 push 等修改方法vec.push(item)FnMut + FnOnce

FnMut 作为函数参数 ​

rust
// 接受 FnMut 闭包
fn apply_n_times<F: FnMut(usize)>(n: usize, mut f: F) {
    for i in 0..n {
        f(i);
    }
}

// 返回修改后的数据
fn transform_all<T, F>(data: &mut Vec<T>, mut f: F)
where
    F: FnMut(&mut T),
{
    for item in data.iter_mut() {
        f(item);
    }
}

// 带累积状态的 FnMut
fn scan_sum(nums: &[i32]) -> Vec<i32> {
    let mut total = 0;
    nums.iter()
        .map(|&x| {
            total += x;  // FnMut:修改捕获的 total
            total
        })
        .collect()
}

fn main() {
    // apply_n_times
    let mut log = Vec::new();
    apply_n_times(5, |i| {
        log.push(format!("步骤 {}", i + 1));
    });
    println!("日志: {:?}", log);

    // transform_all
    let mut prices = vec![100.0, 200.0, 300.0, 400.0];
    let discount = 0.8;
    transform_all(&mut prices, |price| {
        *price *= discount;  // FnMut:修改每个价格
    });
    println!("打折后: {:?}", prices);

    // scan_sum
    let nums = vec![1, 2, 3, 4, 5];
    let running_sum = scan_sum(&nums);
    println!("累积和: {:?}", running_sum);
}

标准库中使用 FnMut 的方法 ​

rust
fn main() {
    // sort_by:接受 FnMut
    let mut names = vec!["Charlie", "Alice", "Bob", "David"];
    names.sort_by(|a, b| a.cmp(b));
    println!("排序: {:?}", names);

    // sort_by_key:接受 FnMut
    let mut words = vec!["hello", "hi", "hey", "howdy"];
    words.sort_by_key(|w| w.len());
    println!("按长度排序: {:?}", words);

    // retain:接受 FnMut
    let mut nums = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
    let mut removed = Vec::new();
    nums.retain(|&x| {
        if x % 3 == 0 {
            removed.push(x);  // FnMut:修改 removed
            false
        } else {
            true
        }
    });
    println!("保留: {:?}", nums);
    println!("移除: {:?}", removed);

    // for_each:接受 FnMut
    let mut sum = 0;
    vec![10, 20, 30].iter().for_each(|&x| {
        sum += x;  // FnMut
    });
    println!("总和: {}", sum);

    // map 也接受 FnMut(虽然通常用 Fn 就够了)
    let mut index = 0;
    let indexed: Vec<String> = vec!["a", "b", "c"].iter()
        .map(|&s| {
            index += 1;  // FnMut
            format!("{}. {}", index, s)
        })
        .collect();
    println!("编号: {:?}", indexed);
}

基本示例 ​

用 FnMut 构建一个状态追踪器:

rust
struct Tracker<F>
where
    F: FnMut(&str) -> String,
{
    processor: F,
    history: Vec<String>,
}

impl<F> Tracker<F>
where
    F: FnMut(&str) -> String,
{
    fn new(processor: F) -> Self {
        Tracker {
            processor,
            history: Vec::new(),
        }
    }

    fn process(&mut self, input: &str) -> String {
        let result = (self.processor)(input);  // FnMut 调用
        self.history.push(format!("{} → {}", input, result));
        result
    }

    fn print_history(&self) {
        println!("处理历史:");
        for (i, entry) in self.history.iter().enumerate() {
            println!("  [{}] {}", i + 1, entry);
        }
    }
}

fn main() {
    // FnMut 闭包:带累积编号的格式化器
    let mut seq = 0;
    let mut tracker = Tracker::new(move |input: &str| {
        seq += 1;  // 修改捕获的 seq
        format!("#{:03} {}", seq, input.to_uppercase())
    });

    tracker.process("hello");
    tracker.process("world");
    tracker.process("rust");
    tracker.print_history();

    println!();

    // FnMut 实现累积计算
    let mut running_total = 0.0_f64;
    let mut count = 0_u32;
    let mut stats_processor = |value: f64| {
        running_total += value;
        count += 1;
        running_total / count as f64  // 返回平均值
    };

    let values = vec![85.0, 92.0, 78.0, 95.0, 88.0];
    println!("逐步录入成绩:");
    for v in &values {
        let avg = stats_processor(*v);
        println!("  录入 {:.0},当前平均: {:.1}", v, avg);
    }
    println!("共{}条,总分{:.0},平均{:.1}",
        count, running_total, running_total / count as f64);
}

常见问题 ​

问题一:为什么 FnMut 闭包的变量需要声明为 mut?

因为 FnMut 通过 &mut self 调用闭包,这需要对闭包本身的可变引用。如果变量不是 mut,就无法获取 &mut 引用来调用它。

问题二:Fn 闭包可以传给 FnMut 参数吗?

可以。Fn 是 FnMut 的子 trait,实现了 Fn 的闭包自动实现 FnMut。反过来不行——FnMut 闭包不一定实现 Fn。

问题三:标准库的迭代器方法为什么用 FnMut 而不是 Fn?

因为 FnMut 比 Fn 更宽松,可以接受更多种类的闭包。像 map、filter 等方法用 FnMut 可以让用户在闭包中维护状态(如计数、累加),同时也兼容 Fn 闭包。

问题四:move 闭包修改数据后是 FnMut 吗?

取决于闭包体的行为。move 只影响捕获方式。如果 move 闭包修改了捕获的数据,它实现 FnMut;如果只读取,实现 Fn。

适用场景 ​

  • 累加器/计数器:维护可变状态的闭包
  • 收集器:在遍历过程中收集结果
  • 迭代器方法:sort_by、retain、for_each
  • 状态机:闭包每次调用时状态转换

注意事项 ​

  • FnMut 闭包的变量必须声明为 mut
  • FnMut 通过 &mut self 调用,持有可变借用期间不能再借用闭包
  • 实现 Fn 的闭包自动实现 FnMut
  • 标准库多数迭代器方法接受 FnMut 而非 Fn
  • 函数参数写 mut f: impl FnMut() 或 f: &mut dyn FnMut()
  • FnMut 闭包可以多次调用

总结 ​

FnMut trait 表示闭包通过 &mut self 调用,可以修改捕获的变量。FnMut 闭包可以多次调用,每次调用都可能改变内部状态。持有 FnMut 闭包的变量必须声明为 mut。Fn 是 FnMut 的子 trait,所以 Fn 闭包可以传给 FnMut 参数。标准库中 sort_by、retain、map、filter 等迭代器方法大多接受 FnMut,让用户可以在闭包中维护状态。典型应用场景是累加器、计数器、收集器等需要在多次调用间保持和修改状态的情况。