Rust By Practice《Fighting with Compiler》实战解析:借用检查错误与 `self.list.iter()` 修复方案

原创2026-09-21 10:03:481,747 阅读
文章标签:文档教程教育

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)的两条核心规则:

  1. 同一时刻只能存在一个可变借用(mutable borrow);
  2. 可变借用与不可变借用不能同时存在。

这两条规则的权威练习版本可以在 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]) 时,会按以下顺序推断:

  1. self.list.len():len() 是 Vec 的不可变方法,会先对 self.list 产生一个不可变借用(尽管循环条件在一次迭代结束后就会被释放,编译器会单独处理)。
  2. self.list[i]:这是对 self.list 的不可变索引访问,Vec 实现了 Index trait,self.list[i] 等价于 *self.list.index(i),产生一个不可变借用,取出的 i32 是一个 Copy 类型的值。
  3. 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)
}

这里发生了两个本质变化:

  1. self.list.iter():Vec::iter() 返回一个迭代器 std::slice::Iter<'_, i32>,它只对 self.list 这一个字段产生不可变借用,而不再是对整个 self 的借用。借用被精确地限制在 list 字段上。
  2. *i:迭代器每次 next() 产出的是 &i32(对列表中元素的不可变引用),*i 解引用后得到 i32。由于 i32 实现了 Copy trait,解引用会拷贝出一个值,这个值不再持有任何借用——它是"裸数据"。

于是,当编译器检查 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 错误(不可变借用与可变借用冲突)时,可以按以下顺序排查解决:

  1. 缩小借用范围:不要借整个 self/结构体,只借你真正需要的字段(如 self.list.iter()),让可变借用获得独占权;
  2. 借用到值为止:对 Copy 类型,用 * 解引用立即把引用转成值,让借用立刻终结,如 *i;
  3. 拆分语句:借助 NLL,把"取值"与"调用 &mut 方法"拆成两条语句,让不可变借用在其最后使用点提前释放;
  4. 避免 iter_mut() 与 &mut self 并存:可变迭代器同样会占用可变借用,无法与 &mut self 方法共存;
  5. 实在绕不开再考虑 clone():以拷贝换编译通过,但要注意性能成本。

官方答案 self.list.iter() 恰恰是第 1、2 条的组合运用:借用只落在字段、值随 *i 立即拷贝。把这套"缩小借用范围 + 提前终结借用"的心法内化,你就能在绝大多数 E0502 报错面前快速定位并给出最优解——这正是 Fighting with Compiler 一章希望你在反复练习中获得的"编译器直觉"。

登录后查看全文
rust-by-practice