引用与借用规则回顾

借用规则: 从规则到推理

基础篇记住了那条铁律--共享不可变, 可变不共享: 同一数据, 要么任意多个 &T, 要么唯一一个 &mut T, 二者不并存. 进阶篇要问的是: 编译器具体怎么判断两个借用是否冲突?

答案的核心是: 借用检查器关心的不是"写了几个 &", 而是"每个借用实际存活的范围是否重叠". 理解这一点, 很多"看似该报错却没报错"或"看似无害却报错"的现象就都说得通了.

NLL: 借用到"最后一次使用"为止

这是理解借用范围的关键机制, 叫非词法生命周期(NLL, Non-Lexical Lifetimes). 一个引用的存活范围, 不是从声明到作用域大括号结束, 而是从声明到它最后一次被使用为止. 之后它就"死了", 不再参与冲突判断.

let mut s = String::from("hello");

let r1 = &s;          // 不可变借用开始
let r2 = &s;
println!("{r1} {r2}"); // r1, r2 最后一次使用 -- 它们的借用到此结束

let r3 = &mut s;       // OK! 此刻 r1/r2 已"死", 不再与可变借用冲突
r3.push_str("!");

如果按"借用持续到作用域结束"的旧规则, 上面会报错(可变与不可变借用共存). NLL 让编译器看得更细: 既然 r1/r2 在 r3 出现前就用完了, 自然无冲突.

可变性分割: 同时借用不同字段

一个常被忽略, 却极实用的能力: 借用检查器能识别"借用的是结构体的不同字段", 从而允许同时持有它们的可变引用.

struct Point { x: i32, y: i32 }

let mut p = Point { x: 1, y: 2 };
let rx = &mut p.x; // 可变借用 x
let ry = &mut p.y; // 可变借用 y -- OK! x 和 y 是不同字段, 互不冲突
*rx += 10;
*ry += 20;

因为 p.x 和 p.y 是内存上不相交的两块, 同时可变借用它们不会违反"可变不共享"--它们本就不是同一份数据.

重借用: &mut 为什么能传来传去

&mut T 是不可 Copy 的(它要保证独占). 那为什么下面的代码能正常工作?

fn add_one(n: &mut i32) {
    *n += 1;
}

let mut x = 5;
let r = &mut x;
add_one(r);        // 把 r 传进去
add_one(r);        // 居然还能再用 r?

如果 &mut 像 String 那样被移动, 第一次 add_one(r) 后 r 就该失效了. 它没失效, 是因为发生了重借用(reborrow): 编译器自动把 add_one(r) 解释成 add_one(&mut *r)--临时从 r 再借一个新的可变引用传进去, 这个临时借用在函数返回时结束, r 的所有权从未离开.

快速回顾

• 从规则到推理: 借用检查器判断的是"借用存活范围是否重叠", 而非 & 的个数.
• NLL: 借用到"最后一次使用"为止即结束; 尽早用完引用可化解多数冲突.
• 字段分割: 可同时可变借用结构体的不同字段(内存不相交); 但经由 &mut self 的方法则不行.
• 重借用: &mut 不可 Copy, 但传参时自动 &mut *r 临时转借, 原引用不失效.
• 意义: 这些机制是读懂生命周期与复杂借用报错的地基.

动手练习

1. 下面代码能编译吗? 如不能, 用 NLL 思路解释, 并修复.

   let mut v = vec![1, 2, 3]; let first = &v[0]; v.push(4); println!("{first}");

let mut v = vec![1, 2, 3];
let first = v[0]; // 直接 Copy 出值(i32 是 Copy), 不再持有借用
v.push(4);
println!("{first}");

2. 解释为什么下面能编译, 涉及哪个机制.

   struct Pair { a: String, b: String } let mut p = Pair { a: "x".into(), b: "y".into() }; let ra = &mut p.a; let rb = &mut p.b; ra.push('!'); rb.push('?');

3. 写一个函数 fn bump(n: &mut i32) 把值加一, 然后在 main 中对同一个 &mut 连续调用它两次, 解释为什么第二次调用时引用没有失效.

fn bump(n: &mut i32) {
    *n += 1;
}

fn main() {
    let mut x = 0;
    let r = &mut x;
    bump(r); // 自动重借用为 bump(&mut *r)
    bump(r); // r 仍有效, 再次重借用
    println!("{r}"); // 2
}