&T 与 &mut T 规则 ​

面试题 ​

请解释 Rust 中 &T(不可变引用)和 &mut T(可变引用)的借用规则,为什么要这样设计?

考察意图 ​

考察候选人对 Rust 借用检查器核心规则的理解,以及这些规则如何在编译期防止数据竞争和悬垂引用。这是 Rust 面试中出现频率最高的问题之一。

答题要点 ​

借用规则 ​

Rust 的借用规则可以归纳为两条:

  1. 同一时刻,可以有任意多个不可变引用(&T),或者恰好一个可变引用(&mut T),但两者不能共存。
  2. 引用的生命周期不能超过被引用值的生命周期(不能产生悬垂引用)。
rust
fn main() {
    let mut data = vec![1, 2, 3];

    // === 多个不可变引用:允许 ===
    let r1 = &data;
    let r2 = &data;
    println!("{:?} {:?}", r1, r2);  // 同时使用多个 &T

    // === 一个可变引用:允许 ===
    let r3 = &mut data;
    r3.push(4);
    println!("{:?}", r3);

    // === 不可变和可变引用共存:禁止 ===
    // let r4 = &data;
    // let r5 = &mut data;
    // println!("{:?} {:?}", r4, r5);  // 编译错误

    // === 两个可变引用:禁止 ===
    // let r6 = &mut data;
    // let r7 = &mut data;
    // println!("{:?} {:?}", r6, r7);  // 编译错误
}

为什么这样设计 ​

rust
fn main() {
    // 借用规则防止的三类问题:

    // === 1. 防止数据竞争 ===
    // 数据竞争的三个条件:
    // - 两个以上指针同时访问同一数据
    // - 至少一个指针用于写入
    // - 没有同步机制
    // 借用规则在编译期排除了前两个条件

    // === 2. 防止迭代器失效 ===
    let mut v = vec![1, 2, 3];
    // for item in &v {
    //     v.push(*item);  // 编译错误:不能在持有 &v 时修改 v
    //                     // 在 C++ 中这会导致迭代器失效(UB)
    // }

    // === 3. 防止悬垂引用 ===
    // fn dangling() -> &String {
    //     let s = String::from("hello");
    //     &s  // 编译错误:s 在函数结束时被 drop,引用会悬垂
    // }

    println!("借用规则在编译期消除了这些运行时 bug");
}

NLL(Non-Lexical Lifetimes) ​

rust
fn main() {
    let mut data = String::from("hello");

    // NLL 让引用的生命周期在最后一次使用后就结束
    // 而不是延续到作用域结束

    let r1 = &data;
    println!("{}", r1);
    // r1 的生命周期到此结束(NLL)

    // 现在可以获取可变引用了
    let r2 = &mut data;
    r2.push_str(" world");
    println!("{}", r2);

    // 没有 NLL 时(Rust 2015 的旧行为):
    // r1 的生命周期会延续到作用域结束
    // 导致 r2 的可变借用失败
}

常见追问 ​

追问一:&T 和 &mut T 在内存中有什么区别?

在内存表示上没有区别,都是一个指针(8 字节,64 位系统)。区别完全在编译期的借用检查——编译器追踪每个引用的可变性和生命周期,在编译期排除违规情况。

追问二:可以绕过借用规则吗?

可以。unsafe 块中可以使用裸指针(*const T、*mut T),不受借用检查约束。RefCell<T> 将借用检查推迟到运行时。UnsafeCell<T> 是所有内部可变性的基础。

追问三:为什么 &T 是 Copy 但 &mut T 不是?

&T 是 Copy 的,因为多个不可变引用可以共存。&mut T 不能 Copy,因为可变引用的唯一性——如果 Copy 了就会有两个可变引用,违反借用规则。

基本示例 ​

rust
// 实际应用中的借用模式

fn first_word(s: &str) -> &str {
    // 接收不可变借用,返回子切片引用
    let bytes = s.as_bytes();
    for (i, &byte) in bytes.iter().enumerate() {
        if byte == b' ' {
            return &s[..i];
        }
    }
    s
}

fn append_greeting(s: &mut String) {
    // 接收可变借用,修改原始数据
    s.push_str(", welcome!");
}

struct Counter {
    count: u32,
}

impl Counter {
    fn value(&self) -> u32 {
        // &self 是不可变借用
        self.count
    }

    fn increment(&mut self) {
        // &mut self 是可变借用
        self.count += 1;
    }
}

fn main() {
    let text = String::from("hello world");
    let word = first_word(&text);
    println!("第一个词: {}", word);

    let mut name = String::from("Alice");
    append_greeting(&mut name);
    println!("{}", name);

    let mut counter = Counter { count: 0 };
    counter.increment();
    counter.increment();
    println!("计数: {}", counter.value());
}

常见问题 ​

问题一:方法中 &self 和 &mut self 怎么选择?

如果方法不修改结构体的任何字段,用 &self。如果需要修改字段,用 &mut self。如果需要消费结构体(如转换为另一个类型),用 self。

问题二:reborrow 是什么?

对 &mut T 再次取不可变引用 &*r 或 &**r 叫做 reborrow。编译器在很多情况下会自动 reborrow,让可变引用临时降级为不可变引用。

适用场景 ​

  • 函数参数:用 &T 读取数据,&mut T 修改数据
  • 方法签名:&self 观察状态,&mut self 修改状态
  • 迭代器:iter() 返回 &T,iter_mut() 返回 &mut T
  • 并发安全:借用规则在编译期防止数据竞争

注意事项 ​

  • 不可变引用和可变引用不能同时存在
  • 同一时刻最多一个可变引用
  • NLL 让引用在最后使用后就结束
  • &T 是 Copy,&mut T 不是
  • RefCell 将检查推迟到运行时
  • 裸指针可以绕过借用检查(unsafe)

总结 ​

Rust 的借用规则——同一时刻任意多个 &T 或恰好一个 &mut T——在编译期防止数据竞争、迭代器失效和悬垂引用。&T 和 &mut T 在内存中都是普通指针,区别完全在编译期检查。NLL 让引用生命周期在最后使用处结束而非作用域结束。&T 是 Copy(可以多个共存),&mut T 不是(必须唯一)。RefCell 提供运行时借用检查,unsafe 裸指针可以绕过编译期检查。