Rust By Practice《Fighting with Compiler》实战解析:借用检查错误与 `self.list.iter()` 修复方案
Rust By Practice《Fighting with Compiler》实战解析:借用检查错误与 self.list.iter() 修复方案
本文基于 rust-by-practice 仓库中 solutions/fight-compiler/borrowing.md 这道题的答案展开。该练习属于 Fighting with Compiler(与编译器战斗)章节——这是一个专门用于帮助开发者克服 Rust 陡峭学习曲线的实战章节。本文将从"题目为何编译失败"出发,逐步拆解借用检查器的判定逻辑,剖析官方答案
self.list.iter()的修复原理,并延伸讲解可替代的多种修复策略,帮助你彻底掌握"可变借用与不可变借用冲突"这一类最典型的 Rust 编译错误。
题目与官方答案
练习题原文
英文练习位于 en/src/fight-compiler/borrowing.md,难度标记为 🌟🌟,题目要求是:
FIX the error without removing any code line(修复错误,但不要删除任何一行代码)
// FIX the error without removing any code line
struct test {
list: Vec<i32>,
a: i32
}
impl test {
pub fn new() -> Self {
test { list:vec![1,2,3,4,5,6,7], a:0 }
}
pub fn run(&mut self) {
for i in 0..self.list.len() {
self.do_something(self.list[i])
}
}
pub fn do_something(&mut self, n: i32) {
self.a = n;
}
}
fn main() {}
这段代码在 cargo build / rustc 编译时会直接报错。题目的约束是"不能删除任何一行代码",这意味着你不能靠删掉 self.do_something(...) 调用或删掉循环来绕过问题,只能通过修改已有代码行的方式让代码通过编译。
官方答案
仓库中对应的答案文件 solutions/fight-compiler/borrowing.md 给出的修复方案,是把 run 方法里的循环体从"按索引访问"改为"迭代器访问":
struct test {
list: Vec<i32>,
a: i32
}
impl test {
pub fn new() -> Self {
test { list:vec![1,2,3,4,5,6,7], a:0 }
}
pub fn run(&mut self) {
for i in self.list.iter() {
self.do_something(*i)
}
}
pub fn do_something(&mut self, n: i32) {
self.a = n;
}
}
fn main() {}
对比一下两处关键改动:
| 位置 | 错误版本 | 官方答案 |
|---|---|---|
| 循环遍历 | for i in 0..self.list.len() |
for i in self.list.iter() |
| 取值方式 | self.do_something(self.list[i]) |
self.do_something(*i) |
改动量极小,但背后的借用检查语义差异非常大。接下来我们就来分析:为什么原来的写法必然编译失败,而改成迭代器后就能通过。
为什么原代码必然编译失败:一次 "self 的双重借用" 冲突
借用检查器的两条铁律
要理解这个错误,需要先回顾 Rust 借用(borrowing)的两条核心规则:
- 同一时刻只能存在一个可变借用(mutable borrow);
- 可变借用与不可变借用不能同时存在。
这两条规则的权威练习版本可以在 en/src/ownership/borrowing.md 的第 7~9 题中看到,其官方答案在 solutions/ownership/borrowing.md:
- 第 7 题展示了两个
&mut同时存在会导致cannot borrow ... as mutable more than once at a time错误; - 第 8 题展示了"把不可变对象借为可变"会报
cannot borrow ... as mutable, as it is not declared as mutable; - 第 9 题则验证了"把可变对象借为不可变"是合法的。
而在 run 方法中,问题出在同一个 self 身上同时发生了两种借用。
逐步还原编译器的判定
原代码的 run 方法签名是:
pub fn run(&mut self) {
for i in 0..self.list.len() {
self.do_something(self.list[i])
}
}
编译器在检查循环体 self.do_something(self.list[i]) 时,会按以下顺序推断:
self.list.len():len()是Vec的不可变方法,会先对self.list产生一个不可变借用(尽管循环条件在一次迭代结束后就会被释放,编译器会单独处理)。self.list[i]:这是对self.list的不可变索引访问,Vec实现了Indextrait,self.list[i]等价于*self.list.index(i),产生一个不可变借用,取出的i32是一个Copy类型的值。self.do_something(...):do_something的签名是pub fn do_something(&mut self, n: i32),调用它需要获得对整个self的可变借用。
关键冲突点就在这里:当你调用 self.do_something(self.list[i]) 时,参数 self.list[i] 还持有对 self.list 的不可变借用,而 self.do_something 又需要 &mut self。 Rust 不允许在同一表达式内,对一个对象的整体求可变借用、同时对它的字段求不可变借用,因为可变借用要求"独占访问权"。于是编译器报出经典的错误:
error[E0502]: cannot borrow `*self` as mutable because it is also borrowed as immutable
这正是 Fighting with Compiler 章节要训练你识别的那一类"看起来合理、实际违反借用规则"的代码:方法内部既想读 self 的字段,又想调用需要 &mut self 的方法。
官方答案的修复原理:iter() 切断了冲突链条
iter() 到底做了什么
官方答案把循环改成:
for i in self.list.iter() {
self.do_something(*i)
}
这里发生了两个本质变化:
self.list.iter():Vec::iter()返回一个迭代器std::slice::Iter<'_, i32>,它只对self.list这一个字段产生不可变借用,而不再是对整个self的借用。借用被精确地限制在list字段上。*i:迭代器每次next()产出的是&i32(对列表中元素的不可变引用),*i解引用后得到i32。由于i32实现了Copytrait,解引用会拷贝出一个值,这个值不再持有任何借用——它是"裸数据"。
于是,当编译器检查 self.do_something(*i) 时:
- 参数
*i是一个已拷贝出来的i32值,与self没有任何借用关系; - 调用
do_something时对self的可变借用是独占的,不存在并存的不可变借用。
借用冲突的链条(self.list 不可变借用 → &mut self)被彻底切断,代码自然通过编译。
为什么答案特意用 iter() 而不是别的方式
Vec 有三种迭代方式,语义各不相同,这正是本题考察的"隐藏知识点":
| 方法 | 产出类型 | 借用方式 | 在本场景中的可行性 |
|---|---|---|---|
iter() |
&i32 |
对 self.list 不可变借用 |
✅ 官方方案,借用精确限定在 list 字段 |
iter_mut() |
&mut i32 |
对 self.list 可变借用 |
⚠️ 仍然与 &mut self 冲突,同样报错 |
into_iter() |
i32(所有权转移) |
需要拥有 self.list |
❌ self 是 &mut self,无法转移字段所有权 |
可以看到:iter_mut() 和 into_iter() 在"既要遍历 self.list,又要调用 &mut self 方法"的场景下都行不通——前者仍有可变借用冲突,后者会试图移动 self 的部分字段。只有 iter() 这种"不可变借用 + Copy 拷贝取值"的组合能同时满足遍历与后续可变方法调用的需求。这也是 Rust 中"把引用转成值再使用"来规避借用冲突的典型手法。
深入理解:三种可替代的修复方案对比
虽然官方答案选择了 iter(),但理解"为什么能修、为什么那样修"才是本章的真正目标。下面给出同样满足"不删除代码行"约束的几种替代写法,供你对照思考:
方案 A:先拷贝长度,再按索引循环
pub fn run(&mut self) {
let len = self.list.len(); // 先取走长度这个 Copy 值
for i in 0..len {
self.do_something(self.list[i]);
}
}
原理:把 self.list.len() 的结果先拷到局部变量 len 中,循环条件不再借用 self;循环体内 self.list[i] 的不可变借用只存在于取值的瞬间,与 do_something 的 &mut self 依旧在同一表达式内共存——注意:这个方案其实仍然会报错,因为 self.do_something(self.list[i]) 中参数求值仍发生在可变借用之前。真正可行的写法是:
pub fn run(&mut self) {
let len = self.list.len();
for i in 0..len {
let n = self.list[i]; // 先拷贝出 i32 值,借用立即结束
self.do_something(n); // 再调用可变方法
}
}
关键差异:把"取值"和"调用可变方法"拆成两条语句,self.list[i] 的不可变借用在其所在语句结束时就被释放(NLL,见下文),此时再获取 &mut self 就互不冲突了。
方案 B:复制整个列表(不推荐,仅作思路参考)
pub fn run(&mut self) {
let list = self.list.clone();
for i in 0..list.len() {
self.do_something(list[i]);
}
}
原理:clone() 得到一份独立的 Vec<i32>,循环完全脱离 self,不再有任何借用冲突。代价是每次 run 都发生一次堆内存拷贝,性能较差,实战中一般不用。
方案 C:官方答案(最优)
pub fn run(&mut self) {
for i in self.list.iter() {
self.do_something(*i)
}
}
优点:无额外内存分配、无整表拷贝;借用只发生在 list 字段上,且通过 Copy 解引用立即终结,是语义最精确、性能最好的写法。这也是官方答案选它的原因。
支撑原理:NLL(Non-Lexical Lifetimes,非词法生命周期)
为什么"先取值、再调用"能通过编译?这背后是 Rust 2018 起引入的 NLL 机制。在旧版的"词法生命周期"(lexical lifetimes)规则下,一个借用会存活到所在作用域结束;而 NLL 让借用只存活到最后一次使用它的位置。
en/src/ownership/borrowing.md 的第 10、11 题(答案见 solutions/ownership/borrowing.md)专门训练这一概念:
// 第 10 题答案(注释掉最后的 println! 后编译通过)
let r1 = &mut s;
r1.push_str("world");
let r2 = &mut s; // r1 在上一条语句后不再被使用,借用提前结束
r2.push_str("!");
正是因为 NLL,r1 的借用在其"最后一次使用"(r1.push_str("world"))之后立即结束,r2 才能随后获得可变借用。同理,方案 A 中 let n = self.list[i]; 的不可变借用也在该语句结束时失效,后续 self.do_something(n) 才能合法地拿到 &mut self。理解 NLL,是读懂"哪些借用冲突可以靠重排语句解决、哪些必须靠迭代器/拷贝绕开"的关键。
知识串联:把这道题放进整本书的上下文
这道题并不是孤立的,它在 rust-by-practice 的知识体系中处于一个承上启下的位置:
- 前置基础:完整的借用规则(同一时刻一个可变借用、可变与不可变互斥、可变对象可被不可变借用)在 en/src/ownership/borrowing.md 中通过 11 道由浅入深的练习题系统讲解;
- 本章定位:
Fighting with Compiler章节(见 en/src/fight-compiler/intro.md)的初衷,就是"把日常编码中常见的编译错误变成练习题",让你在遇到真实项目报错时不再手足无措。Borrowing是这一章的开门题,后面还会继续训练各类借用、生命周期相关的编译器报错; - 延伸主题:当你掌握"借用冲突的规避"后,可以继续学习生命周期(en/src/lifetime/intro.md)、以及
Rc/RefCell等打破借用检查约束的智能指针(en/src/smart-pointers/rc-arc.md),形成完整的"所有权与借用"知识闭环。
本书的定位是"用有挑战性的示例、练习和项目来实践 Rust"(见 Readme.md),所有练习均可在本地通过 mdbook 运行:先 cargo install mdbook,再执行 mdbook serve en/(英文版)或 mdbook serve zh-CN/(中文版)即可在线编辑运行题目(仓库配置文件见 en/book.toml,其中 edition = "2021" 表明练习题默认按 Rust 2021 版编译)。
总结:遇到 "borrow ... as mutable because it is also borrowed as immutable" 该怎么办
当你在实战中遇到与本题相同的 E0502 错误(不可变借用与可变借用冲突)时,可以按以下顺序排查解决:
- 缩小借用范围:不要借整个
self/结构体,只借你真正需要的字段(如self.list.iter()),让可变借用获得独占权; - 借用到值为止:对
Copy类型,用*解引用立即把引用转成值,让借用立刻终结,如*i; - 拆分语句:借助 NLL,把"取值"与"调用
&mut方法"拆成两条语句,让不可变借用在其最后使用点提前释放; - 避免
iter_mut()与&mut self并存:可变迭代器同样会占用可变借用,无法与&mut self方法共存; - 实在绕不开再考虑
clone():以拷贝换编译通过,但要注意性能成本。
官方答案 self.list.iter() 恰恰是第 1、2 条的组合运用:借用只落在字段、值随 *i 立即拷贝。把这套"缩小借用范围 + 提前终结借用"的心法内化,你就能在绝大多数 E0502 报错面前快速定位并给出最优解——这正是 Fighting with Compiler 一章希望你在反复练习中获得的"编译器直觉"。