FnMut Trait 可变借用
核心概念
FnMut 是三个闭包 trait 中的中间层,表示闭包需要对捕获的变量进行可变借用(&mut T)。实现了 FnMut 的闭包可以被多次调用,每次调用都可能修改其内部状态。调用 FnMut 闭包时需要通过 &mut self,所以持有闭包的变量必须声明为 mut。FnMut 是 FnOnce 的子 trait,实现了 FnMut 的闭包自动实现 FnOnce,但不一定实现 Fn。
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 的调用方式
// 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 的区别
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 += 1 | FnMut + FnOnce |
| 消耗变量 | drop(x) | FnOnce |
| 调用 push 等修改方法 | vec.push(item) | FnMut + FnOnce |
FnMut 作为函数参数
// 接受 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 的方法
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 构建一个状态追踪器:
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闭包的变量必须声明为mutFnMut通过&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,让用户可以在闭包中维护状态。典型应用场景是累加器、计数器、收集器等需要在多次调用间保持和修改状态的情况。