在 C 语言中,手动管理内存容易导致悬垂指针、double free、内存泄漏;在 Java/Go 中引入 GC 又带来运行时开销和停顿。Rust 想同时拥有性能和安全,于是发明了所有权系统:每一个值都有一个唯一确定的所有者,所有者离开作用域时,值被自动回收。 这一切都在编译期完成检查,没有运行时开销。
三个基本规则
- 每个值都有一个所有者(owner)变量。
- 同一时间只有一个所有者。
- 所有者离开作用域时,值被丢弃(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 仍可用
引用的两条铁律
- 同时只允许一个可变引用(
&mut),或任意多个不可变引用(&),二者不能共存。 - 引用必须始终有效(不能返回指向已释放内存的引用,见生命周期章节)。
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 下也能修改
}
}
易错点与陷阱
- 移动后使用:传值给函数再访问原变量 → 编译错误。改用引用或
.clone()。 - 可变引用冲突:多个
&mut或&与&mut共存 → 编译错误,需提前结束借用(借助 NLL)。 - 返回悬垂引用:返回指向局部变量的引用 → 编译错误,返回所有权或改用
'static(见生命周期章)。 - 把
Copy与Clone混为一谈:Copy是隐式,Clone需显式.clone()。 - 误用
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 把借用检查推迟到运行时,实现内部可变性。