[Rust] 所有权与引用

1 阅读7分钟

在 C 语言中,手动管理内存容易导致悬垂指针、double free、内存泄漏;在 Java/Go 中引入 GC 又带来运行时开销和停顿。Rust 想同时拥有性能和安全,于是发明了所有权系统:每一个值都有一个唯一确定的所有者,所有者离开作用域时,值被自动回收。  这一切都在编译期完成检查,没有运行时开销。

三个基本规则

  1. 每个值都有一个所有者(owner)变量。
  2. 同一时间只有一个所有者。
  3. 所有者离开作用域时,值被丢弃(drop)。

思考:这相当于把"生命周期"与"变量作用域"绑定,编译器可以静态推演。

移动(Move)语义

Rust 中把值赋给另一个变量、作为参数传递、作为返回值时,默认是移动而非复制 —— 所有权转移了:

let s1 = String::from("hello");
let s2 = s1;          // s1 的所有权被移动到 s2

// println!("{s1}");  // 编译错误!s1 已经被移动,不能再使用

fn take(s: String) {} // 传入即移动,函数拥有所有权
take(s2);             // 之后 s2 不可用

为什么字符串是移动而非复制?

String 在堆上分配内存。若做浅拷贝,s1 和 s2 指向同一块堆内存,作用域结束时双方各自 drop,导致 double free。Rust 选择"移动 + 使原变量失效",从根源上避免了双重释放。

与之相反,i32 等栈上的简单类型实现了 Copy,赋值是整体复制,原变量仍可用:

let a = 5;
let b = a;   // a 仍可用 —— i32 实现 Copy
println!("{a} {b}"); // OK

易错点:Copy 类型被移动时只是复制,而 String、Vec<T>、结构体(默认)不实现 Copy,只有 Clone。二者是不同 trait。Clone 是显式 .clone(),Copy 是隐式自动复制。

深拷贝 clone

需要保留原值时,显式调用 .clone() 进行堆内存的深度复制:

let s1 = String::from("hello");
let s2 = s1.clone(); // 深拷贝,s1、s2 各自独立
println!("{s1} {s2}"); // 都可以使用

clone 与 Copy 的界限

trait行为调用方式适用类型
Copy位级复制隐式数字、布尔、字符、浮点、元组(元素均 Copy)
Clone深拷贝(任意逻辑)显式 .clone()String、Vec、自定义结构体

Copy 是 Clone 的子集:Copy 类型必须也实现 Clone,且克隆就是无条件复制。结构体默认既不 Copy 也不 Clone,需要手动 derive。

借用与引用(Borrowing)

移动解决了 double free,但函数调用总是转移所有权很不方便——我们常常只想读取数据而不想拿它。于是 Rust 提供引用(reference) :借用值而不获取所有权。

fn calculate_length(s: &String) -> usize { // &String 借用
    s.len()
}

let s = String::from("hello");
let len = calculate_length(&s); // 传引用
println!("{s}"); // s 仍可用

引用的两条铁律

  1. 同时只允许一个可变引用(&mut),或任意多个不可变引用(&),二者不能共存。
  2. 引用必须始终有效(不能返回指向已释放内存的引用,见生命周期章节)。
let mut s = String::from("hello");

let r1 = &s;        // 不可变借用 OK
let r2 = &s;        // 多个不可变借用 OK
// let r3 = &mut s; // 编译错误!已有不可变借用

let m = &mut s;     // 可变借用,独占
m.push_str(" world");

可变引用修改数据

fn change(s: &mut String) {
    s.push_str(", world"); // 通过可变引用改写
}
let mut s = String::from("hello");
change(&mut s);

易错点:可变引用的"独占性"是为了避免数据竞争。如果两个可变引用同时写同一块内存,必然产生未定义行为。Rust 在编译期就杜绝了这一点。

引用与悬垂

Rust 编译器拒绝悬垂引用——指向已释放内存的引用:

fn dangle() -> &String {
    let s = String::from("hello");
    &s // 编译错误:s 离开作用域被释放,返回的引用悬垂
}

正确做法是直接返回 String(转移所有权):

fn no_dangle() -> String {
    String::from("hello") // 所有权随返回值一起传递,安全
}

可变性的完整景观

& 与 &mut 是可变性的两面,结合四种组合:

写法含义能否改值
let x = 5绑定不可变否(immutable binding)
let mut x = 5绑定可变是(mutable binding)
fn f(v: &T)不可变借用否
fn f(v: &mut T)可变借用(独占)是

借用作用域:NLL(Non-Lexical Lifetimes)

早期 Rust 中,借用直到所在块结束才释放(词法作用域)。Rust 2018 引入 NLL:借用不再"活"到块末尾,而是最后一次使用时即结束。这让代码更自然:

let mut v = vec![1, 2, 3];
let first = &v[0];    // 不可变借用
println!("{first}");  // 借用最后一次使用结束
v.push(4);            // 现在可以可变借用了 —— NLL 让这合法

分割借用(Split Borrowing)

NLL 的进阶:对结构体不同字段同时进行可变借用是允许的,因为它们不重叠:

struct SplitDemo {
    a: String,
    b: String,
}

let mut s = SplitDemo { a: "x".into(), b: "y".into() };
let ra = &mut s.a;      // 借用 a 字段
let rb = &mut s.b;      // 同时借用 b 字段 —— 合法!

如果试图同时可变借用 s 本身则会冲突。分割借用是 NLL 正确性保障的体现,常用于并发访问结构体不同部分。

内部可变性:Cell 与 RefCell

有时结构体对外是不可变的(&self 方法),但内部需要可变状态(缓存、计数器)。这时用 内部可变性(interior mutability) :

  • Cell<T> :用于 Copy 类型,通过 get/set 移动值进出,无运行时开销、无借用检查冲突。
use std::cell::Cell;

let c = Cell::new(10);
c.set(42);               // 即使 c 本身不可变绑定,也能改内部值
let v = c.get();         // 42
  • RefCell<T> :用于非 Copy 类型,在运行时做借用检查。通过 borrow()(不可变)与 borrow_mut()(可变)获取借用:
use std::cell::RefCell;

let rc = RefCell::new(vec![1, 2, 3]);
{
    let mut b = rc.borrow_mut();
    b.push(4);
}
println!("{:?}", rc.borrow()); // [1, 2, 3, 4]

关键区别:Cell/RefCell 把借用规则从编译期推迟到运行期。违反规则时不会编译报错,而会在运行时 panic。这正是智能指针章节中 Rc<RefCell<T>> 组合模式的基石。

综合示例:内部可变性实战

use std::cell::RefCell;

struct Stats {
    internal: RefCell<Vec<i32>>, // 内部可变
}

impl Stats {
    fn add(&self, v: i32) {
        self.internal.borrow_mut().push(v); // &self 下也能修改
    }
}

易错点与陷阱

  1. 移动后使用:传值给函数再访问原变量 → 编译错误。改用引用或 .clone()。
  2. 可变引用冲突:多个 &mut 或 & 与 &mut 共存 → 编译错误,需提前结束借用(借助 NLL)。
  3. 返回悬垂引用:返回指向局部变量的引用 → 编译错误,返回所有权或改用 'static(见生命周期章)。
  4. 把 Copy 与 Clone 混为一谈:Copy 是隐式,Clone 需显式 .clone()。
  5. 误用 RefCell:borrow_mut 返回的 guard 存活期间再次 borrow_mut → 运行期 panic。

最佳实践

  • 函数默认借用(&T),需要修改才用 &mut T,只有真正要取走所有权才用值传递。
  • 能用 & 就别用 .clone(),克隆有堆分配开销。
  • 结构体字段若需在 &self 下修改,考虑 Cell/RefCell,但要意识到运行时 panic 风险。
  • 优先让借用作用域自然结束(NLL),少用显式 drop 提前释放。

要点回顾

  • 所有权三条铁律由编译器静态检查,杜绝 double free 与悬垂引用。
  • 移动(move)  是 Rust 默认语义;clone 提供显式深拷贝,Copy 提供隐式复制。
  • 借用(borrow)  通过引用进行;不可变引用可多个共存,可变引用独占,二者不可同时存在。
  • NLL 让借用作用域精确到"最后一次使用",避免借用在块尾截止的过度限制。
  • Cell/RefCell 把借用检查推迟到运行时,实现内部可变性。