引用规则总结
核心概念
Rust 的引用系统有一套严格但清晰的规则,这些规则在编译期由借用检查器强制执行,保证内存安全和线程安全。所有规则可以归纳为以下几条。
规则一:引用必须始终有效
引用不能指向已释放的内存。编译器通过生命周期检查确保引用不会超过被引用数据的存活时间。
fn main() {
let r;
{
let s = String::from("hello");
// r = &s; // 编译错误:s 在块结束时被销毁,r 会成为悬垂引用
}
// println!("{}", r); // 如果允许,这里就是使用悬垂引用
// 正确写法:引用不超过数据的生命周期
let s = String::from("hello");
let r = &s;
println!("{}", r); // s 还活着,r 有效
}规则二:同一时间可以有多个不可变引用
多个只读引用可以同时存在,因为只读操作不会相互干扰。
fn main() {
let data = vec![1, 2, 3, 4, 5];
let r1 = &data;
let r2 = &data;
let r3 = &data;
// 三个不可变引用同时使用,完全合法
println!("r1={:?}, r2={:?}, r3={:?}", r1, r2, r3);
}规则三:同一时间只能有一个可变引用
可变引用是独占的,同一时间对同一数据只能有一个可变引用。
fn main() {
let mut s = String::from("hello");
let r1 = &mut s;
// let r2 = &mut s; // 编译错误:已经有一个可变引用了
r1.push_str(" world");
println!("{}", r1);
}规则四:不可变引用和可变引用不能同时存在
这是"别名 XOR 可变"原则——要么有多个只读别名,要么有一个可写引用,不能两者同时存在。
fn main() {
let mut s = String::from("hello");
let r1 = &s; // 不可变引用
let r2 = &s; // 又一个不可变引用
// let r3 = &mut s; // 编译错误:已有不可变引用
println!("{}, {}", r1, r2);
// NLL:r1 和 r2 在上面最后使用,借用结束
// 现在可以创建可变引用了
let r3 = &mut s;
r3.push('!');
println!("{}", r3);
}规则速查表
| 规则 | 描述 | 违反时的错误 |
|---|---|---|
| 引用必须有效 | 引用不能超过数据的生命周期 | borrowed value does not live long enough |
多个 &T 可共存 | 任意数量的不可变引用可同时存在 | — |
&mut T 独占 | 同一时间只能有一个可变引用 | cannot borrow as mutable more than once |
&T 和 &mut T 互斥 | 不可变和可变引用不能同时存在 | cannot borrow as mutable because it is also borrowed as immutable |
| 被借用时不能移动 | 引用存在时不能移动或销毁被引用的值 | cannot move out of because it is borrowed |
NLL 非词法生命周期
NLL(Non-Lexical Lifetimes)让引用的生命周期在最后一次使用时结束,而不是在变量离开作用域时才结束。这大幅减少了不必要的借用冲突。
fn main() {
let mut v = vec![1, 2, 3];
// 没有 NLL 的时代,这段代码无法编译
// 因为 r 的生命周期会延续到作用域结束
let r = &v;
println!("读取: {:?}", r);
// NLL:r 在这里最后使用,借用到此结束
// 现在可以可变借用了
v.push(4);
println!("修改后: {:?}", v);
// 更复杂的 NLL 例子
let mut data = String::from("hello");
let len = calculate_len(&data); // 临时不可变借用
// 借用在 calculate_len 返回后就结束了
data.push_str(" world"); // 可以可变操作
println!("长度={}, 内容={}", len, data);
}
fn calculate_len(s: &str) -> usize {
s.len()
}常见的借用错误场景
在迭代中修改集合
fn main() {
let mut numbers = vec![1, 2, 3, 4, 5];
// 错误:在不可变迭代中修改
// for n in &numbers {
// if *n > 3 {
// numbers.push(*n * 2); // 编译错误:不可变借用中不能可变借用
// }
// }
// 正确方式一:先收集需要的数据,再修改
let to_add: Vec<i32> = numbers.iter()
.filter(|&&n| n > 3)
.map(|&n| n * 2)
.collect();
numbers.extend(to_add);
println!("方式一: {:?}", numbers);
// 正确方式二:用 retain 过滤
let mut data = vec![1, -2, 3, -4, 5];
data.retain(|&x| x > 0);
println!("方式二: {:?}", data);
}结构体方法中的借用冲突
struct Database {
records: Vec<String>,
log: Vec<String>,
}
impl Database {
fn new() -> Self {
Database {
records: Vec::new(),
log: Vec::new(),
}
}
// 这个方法设计会有问题
// fn add_and_log(&mut self, record: &str) {
// self.records.push(record.to_string());
// // 想要在 log 中记录 records 的最后一个元素
// let last = &self.records.last().unwrap(); // 不可变借用 records
// self.log.push(format!("添加: {}", last)); // 可变借用 self(冲突)
// }
// 正确方式:先复制需要的数据
fn add_and_log(&mut self, record: &str) {
self.records.push(record.to_string());
let last = self.records.last().unwrap().clone(); // 复制一份
self.log.push(format!("添加: {}", last));
}
fn show(&self) {
println!("记录: {:?}", self.records);
println!("日志: {:?}", self.log);
}
}
fn main() {
let mut db = Database::new();
db.add_and_log("用户A");
db.add_and_log("用户B");
db.show();
}从集合中获取引用后修改集合
fn main() {
let mut map = std::collections::HashMap::new();
map.insert("a", 1);
map.insert("b", 2);
// 错误:获取引用后尝试插入
// let val = map.get("a"); // 不可变借用
// map.insert("c", 3); // 可变借用(冲突)
// println!("{:?}", val);
// 正确方式一:先用完引用
if let Some(&val) = map.get("a") {
println!("a = {}", val);
}
// 借用结束
map.insert("c", 3);
// 正确方式二:用 entry API
map.entry("d").or_insert(4);
println!("{:?}", map);
}基本示例
展示各种规则在实际代码中的正确运用:
struct TextBuffer {
lines: Vec<String>,
cursor: usize,
}
impl TextBuffer {
fn new() -> Self {
TextBuffer {
lines: vec![String::new()],
cursor: 0,
}
}
// &self 方法:只读操作
fn current_line(&self) -> &str {
&self.lines[self.cursor]
}
fn line_count(&self) -> usize {
self.lines.len()
}
fn total_chars(&self) -> usize {
self.lines.iter().map(|l| l.len()).sum()
}
fn display(&self) {
for (i, line) in self.lines.iter().enumerate() {
let marker = if i == self.cursor { ">" } else { " " };
println!("{} {}: {}", marker, i, line);
}
}
// &mut self 方法:修改操作
fn insert_text(&mut self, text: &str) {
self.lines[self.cursor].push_str(text);
}
fn new_line(&mut self) {
self.cursor += 1;
self.lines.insert(self.cursor, String::new());
}
fn move_to(&mut self, line: usize) {
if line < self.lines.len() {
self.cursor = line;
}
}
fn delete_current_line(&mut self) {
if self.lines.len() > 1 {
self.lines.remove(self.cursor);
if self.cursor >= self.lines.len() {
self.cursor = self.lines.len() - 1;
}
} else {
self.lines[0].clear();
}
}
}
// 只读分析函数:接受不可变引用
fn analyze(buffer: &TextBuffer) {
println!("\n--- 分析 ---");
println!("行数: {}", buffer.line_count());
println!("总字符数: {}", buffer.total_chars());
println!("当前行: '{}'", buffer.current_line());
}
fn main() {
let mut buf = TextBuffer::new();
// 可变操作
buf.insert_text("第一行内容");
buf.new_line();
buf.insert_text("第二行内容");
buf.new_line();
buf.insert_text("第三行内容");
// 只读操作
buf.display();
analyze(&buf);
// 可变操作
buf.move_to(1);
buf.insert_text("(已编辑)");
// 只读操作
buf.display();
analyze(&buf);
// 可变操作
buf.delete_current_line();
println!("\n删除后:");
buf.display();
}常见问题
问题一:为什么 Rust 要这么严格?
这些规则从编译期就阻止了三类严重问题:悬垂引用(使用已释放的内存)、数据竞争(多线程同时读写)、迭代器失效(遍历中修改集合)。其他语言的这些问题通常在运行时才暴露,调试成本高得多。
问题二:遇到借用冲突怎么解决?
| 冲突场景 | 解决方法 |
|---|---|
| 需要同时读和写 | 先读取并保存结果(clone/copy),再写 |
| 迭代中修改 | 先收集修改操作,迭代后统一执行 |
| 方法间冲突 | 拆分方法,避免同时借用整个 self |
| 需要多个可变引用 | 用 split_at_mut 或拆分字段 |
问题三:引用规则有没有例外?
标准库中的 Cell、RefCell、Mutex 等类型提供了"内部可变性",允许通过不可变引用修改数据。它们把编译期检查推迟到运行时,是引用规则的合法补充。
问题四:规则检查有运行时开销吗?
没有。所有借用规则检查都在编译期完成,编译通过后的代码没有额外的运行时检查开销(除了 RefCell 等运行时检查类型)。
适用场景
- API 设计:通过参数类型(
&T/&mut T/T)表达函数的数据使用意图 - 并发安全:借用规则天然防止数据竞争
- 迭代安全:防止迭代中修改集合
- 资源管理:确保引用不会超过资源的生命周期
注意事项
- 引用不能超过被引用值的生命周期
- 多个
&T可共存,&mut T是独占的 &T和&mut T不能同时存在- 被借用的值不能被移动或销毁
- NLL 让引用在最后一次使用后结束
- 遇到借用冲突时优先考虑调整代码结构而不是到处 clone
Cell/RefCell提供内部可变性,作为规则的补充
总结
Rust 的引用规则可以精炼为四句话:引用必须始终有效、多个不可变引用可以共存、可变引用是独占的、不可变引用和可变引用不能同时存在。这四条规则在编译期由借用检查器强制执行,零运行时开销。NLL 机制让引用在最后一次使用后结束生命周期,减少了不必要的借用冲突。遇到借用冲突时,优先调整代码结构(提前复制数据、拆分操作步骤),而不是盲目 clone。这套规则是 Rust 内存安全和线程安全的基石。