&T 与 &mut T 规则
面试题
请解释 Rust 中 &T(不可变引用)和 &mut T(可变引用)的借用规则,为什么要这样设计?
考察意图
考察候选人对 Rust 借用检查器核心规则的理解,以及这些规则如何在编译期防止数据竞争和悬垂引用。这是 Rust 面试中出现频率最高的问题之一。
答题要点
借用规则
Rust 的借用规则可以归纳为两条:
- 同一时刻,可以有任意多个不可变引用(
&T),或者恰好一个可变引用(&mut T),但两者不能共存。 - 引用的生命周期不能超过被引用值的生命周期(不能产生悬垂引用)。
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); // 编译错误
}为什么这样设计
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)
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 了就会有两个可变引用,违反借用规则。
基本示例
// 实际应用中的借用模式
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 裸指针可以绕过编译期检查。