Rust 借用检查器实战:用 rust-by-practice 的 Borrowing 练习驯服 E0502 借用错误

原创2026-09-21 14:39:151,668 阅读
文章标签:文档教程教育

Rust 借用检查器实战:用 rust-by-practice 的 Borrowing 练习驯服 E0502 借用错误

借用(Borrowing)是 Rust 所有权体系中承上启下的核心机制:所有权(Ownership)决定了"值在何时被释放",而借用则决定了"值在被借用期间如何被安全地读取与修改"。在 rust-by-practice 的练习体系中,en/src/fight-compiler/borrowing.md 以一道贴近真实项目的编译错误题目,专门训练开发者识别并修复"迭代器持有不可变借用时又调用 &mut self 方法"这一类最典型的借用冲突。本文将以该练习为骨架,结合 en/src/ownership/borrowing.md 的规则要点与 solutions/fight-compiler/borrowing.md 的官方解法,拆解借用规则的底层原理、编译器报错路径与可复用的实战修复策略。

一、练习背景:与编译器"战斗"的日常

在真实 Rust 项目中,编译错误并不代表能力不足,而是借用检查器在替你拦截未定义行为。正如 en/src/fight-compiler/intro.md 所言,"与编译器战斗"在每日编码中非常常见,尤其是对 Rust 还不熟悉的开发者。该章节的定位正是通过一组精心设计的练习,帮助读者理解编译器报错的成因,从而降低 Rust 陡峭的学习曲线。

本章中的 Borrowing 练习聚焦于一个单一、但极具代表性的错误场景:在持有不可变借用(&self.list)的情况下,又调用需要可变借用(&mut self)的方法。这一模式在真实项目中几乎每天都会出现,例如"遍历集合的同时更新对象的其他字段"。

二、原题解析:一段真实的编译失败代码

练习要求:在不删除任何代码行的前提下修复编译错误(原题见 en/src/fight-compiler/borrowing.md):

// 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 self.list.iter() {
            self.do_something(*i)
        }
    }

    pub fn do_something(&mut self, n: i32) {
        self.a = n;
    }
}

fn main() {}

2.1 错误成因:可变借用与不可变借用的冲突

上述代码无法通过编译,借用检查器会报告形如 cannot borrow *self as mutable because it is also borrowed as immutable 的错误。其成因可以从借用的两条基本规则出发分析:

  1. 不可变借用可以同时存在多个;
  2. 可变借用同一时刻只能存在一个;
  3. 不可变借用与可变借用不能同时存在(同一作用域内对同一数据)。

在 run(&mut self) 中:

  • self.list.iter() 返回的迭代器持有一个对 self.list 的不可变借用(即 &Vec<i32>,等价于 &self.list);
  • 循环体内部的 self.do_something(*i) 需要传入 &mut self,即对 self 的可变借用;
  • 由于 &self.list 这个不可变借用尚未释放(迭代器仍在存活期内),编译器拒绝在同一时刻再借出 &mut self。

换句话说,for i in self.list.iter() 使 self 在循环的整个生命周期内都处于"被不可变借用"状态,而 do_something 却要求"独占可变访问权",两者直接冲突。

2.2 借用检查器眼中的生命周期

从借用检查器的视角,问题可以更精确地描述为:iter() 返回的迭代器会借用 self.list,其生命周期至少覆盖整个 for 循环;而 self.do_something(*i) 需要借用整个 self(包括 self.list),且必须是可变借用。当编译器发现"对 self 的一个子字段的不可变借用"与"对整个 self 的可变借用"在同一区域共存时,就会报出 E0502 类错误。这与 en/src/ownership/borrowing.md 第 7 题("Remove something to make it work")中 &mut s 与 &mut s 并存的 E0499 错误,以及第 11 题所注明的 cannot borrow s as mutable more than once at a time,属于同一家族、不同变体的借用冲突。

三、官方解法:索引代替迭代器,打破借用共存

官方解法位于 solutions/fight-compiler/borrowing.md,核心改动只有 run 方法的循环一行:

pub fn run(&mut self) {
    for i in 0..self.list.len() {
        self.do_something(self.list[i])
    }
}

3.1 为什么索引循环可行

将 self.list.iter() 改为 0..self.list.len() 后,循环变量 i 变成了 usize 标量值,不再持有任何对 self.list 的引用。每次迭代体内:

  • self.list[i] 对 self.list 做一次读取(这是 Copy 类型 i32 的索引取值,Vec<i32> 的 Index 实现返回 &i32,经解引用复制出 i32 值);
  • 随后 self.do_something(i) 以 &mut self 调用;
  • 每次对 self.list 的借用都在当条语句结束时释放,不存在跨语句存活的借用,因此 &mut self 可以在下一语句独占访问。

不删除任何代码行的约束也得以满足——解法只改动了循环的迭代方式,没有增删任何语句。

3.2 为什么不能直接使用 self.list[i] 的引用版本

若把循环体改为 for i in self.list.iter() 的同时去掉 *i,即试图把 &i32 传给 do_something,会引入类型错误(do_something 期望 i32 值而非引用),且借用冲突依旧存在。而若试图把 do_something 改为接受引用参数,则会陷入"读取 self.list 时借用 self"的同一困境。因此官方解法选择了最直接、最符合"不删行"约束的路径:让循环不再持有跨迭代存活的引用。

四、错误排查方法论:面对借用错误的分步修复流程

结合本章练习与 en/src/ownership/borrowing.md 中 11 道递进式题目,可以沉淀出一套可复用的排错流程:

4.1 步骤一:读懂错误信息中的"借用来源"

编译器报错时通常会给出三处定位:

  • 冲突位置:哪一行的借用引发了问题;
  • 先前借用:第一个借用从哪一行开始、存活到哪一行;
  • 借用类型:是 &(不可变)还是 &mut(可变)。

例如第 10 题(NLL 场景)中,r1 在最后一次使用之后其借用才结束,因此注释掉最后一行 println!("{}", r1); 即可让 r2 = &mut s 合法化(见 solutions/ownership/borrowing.md 第 10 题解法)。这体现了 NLL(Non-Lexical Lifetimes,非词法生命周期)的核心思想:借用不是"整个作用域"生效,而是"最后一次使用点"之前生效。

4.2 步骤二:判断能否缩短借用存活期

借用冲突的根源往往是"借用活得比需要更久"。常见手段:

  • 把 iter() 改为索引循环(本练习官方解法);
  • 将大表达式拆成多步,让临时借用尽早结束;
  • 将方法拆分为"先取数据、再执行更新"两个阶段。

4.3 步骤三:判断能否拆分借用字段

当方法只访问部分字段时,可以借用具体的字段而非整个 self。例如把 do_something 改为接受 &mut self.a 或独立的 a: &mut i32 参数,就能把对 self.list 的不可变借用与对 self.a 的可变借用"隔离开"——Rust 允许同时借用结构体的不同字段。

4.4 步骤四:必要时考虑内部可变性

若数据结构的借用模式天然冲突(例如缓存、计数器等场景),可以引入 RefCell / Cell 等内部可变性工具(对应仓库 en/src/smart-pointers/cell-refcell.md 章节内容)。注意这是运行时检查,会带来少量开销,应作为最后手段而非首选。

五、规则速查表:从练习反推的借用要点

规则 说明 对应练习
共享借用(&T)可并存 多个不可变引用可同时存在 第 7 题解法(两个 &s)
独占借用(&mut T)互斥 同一时刻只能有一个可变引用 第 7 题、第 11 题
可变与不可变不可共存 对同一数据的 & 与 &mut 不能同时存活 本练习(iter() 与 do_something 冲突)
借用结束于最后一次使用(NLL) 不再使用的借用即刻失效 第 10 题解法(注释最后一行 println!)
借用可变对象为不可变合法 &mut T 可被降级为 &T 使用 第 9 题
借用不可变对象为可变非法 必须先 let mut s 才能 &mut s 第 8 题
ref 关键字等价于 & let ref r2 = c; 与 let r1 = &c; 等价 第 6 题解法

六、如何动手验证

本仓库的练习文档使用 rust,editable 代码块(见 en/book.toml 中 playpen.editable = true 配置),可直接在 mdBook 生成的在线页面中编辑运行。本地验证可任选一种方式:

  1. 将题目代码复制到本地文件(如 main.rs),执行 cargo run 或 rustc main.rs 观察编译器报错;
  2. 对照 solutions/fight-compiler/borrowing.md 的官方解法,替换循环后再次编译,确认通过;
  3. 尝试题目之外的变体:把 for i in self.list.iter() 换成 for i in self.list(会触发所有权转移错误)、或把 do_something 参数改为 &i32(会触发类型不匹配),借此体会不同错误族的表现差异。

仓库 Readme.md 提供了项目整体结构与练习使用方法,scripts/link_solution 脚本则维护着练习页与 solutions 目录下答案页之间的链接关系,方便读者在练习与答案之间对照学习。

结语

通过 rust-by-practice 中这一个"小而精"的 Borrowing 练习,我们可以完整经历一次典型的与借用检查器"战斗"的过程:识别"迭代器不可变借用 + 方法可变借用"的冲突本质、理解索引循环为何能消除跨语句借用、并顺带掌握 NLL、字段级借用与内部可变性等扩展策略。借用规则看似严苛,但一旦理解其"要么共享要么独占、借用止于最后使用"的核心逻辑,绝大多数 E0502/E0499 报错都能在几分钟内定位并修复——这正是 en/src/fight-compiler/intro.md 所强调的、降低学习曲线的关键一步。

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