引用规则总结 ​

核心概念 ​

Rust 的引用系统有一套严格但清晰的规则,这些规则在编译期由借用检查器强制执行,保证内存安全和线程安全。所有规则可以归纳为以下几条。

规则一:引用必须始终有效 ​

引用不能指向已释放的内存。编译器通过生命周期检查确保引用不会超过被引用数据的存活时间。

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 有效
}

规则二:同一时间可以有多个不可变引用 ​

多个只读引用可以同时存在,因为只读操作不会相互干扰。

rust
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);
}

规则三:同一时间只能有一个可变引用 ​

可变引用是独占的,同一时间对同一数据只能有一个可变引用。

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

    let r1 = &mut s;
    // let r2 = &mut s;  // 编译错误:已经有一个可变引用了
    r1.push_str(" world");
    println!("{}", r1);
}

规则四:不可变引用和可变引用不能同时存在 ​

这是"别名 XOR 可变"原则——要么有多个只读别名,要么有一个可写引用,不能两者同时存在。

rust
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)让引用的生命周期在最后一次使用时结束,而不是在变量离开作用域时才结束。这大幅减少了不必要的借用冲突。

rust
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()
}

常见的借用错误场景 ​

在迭代中修改集合 ​

rust
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);
}

结构体方法中的借用冲突 ​

rust
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();
}

从集合中获取引用后修改集合 ​

rust
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);
}

基本示例 ​

展示各种规则在实际代码中的正确运用:

rust
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 内存安全和线程安全的基石。