所有权
这是 Rust 里最重要的一章。理解了所有权(ownership),你就懂了 Rust 的精髓;没理解,你就永远在被编译器骂。
所有权是 Rust 的核心特性。它替代了 GC、也替代了手动 malloc/free——编译期就确定每个值在哪一刻被释放。学起来别扭,但一旦上手,你会觉得非常自然。
1. 内存管理的三条路
在讲所有权之前,先看看语言之间的路线选择:
路线 A:手动管理(C/C++):程序员自己 malloc/free、new/delete。快,但容易忘记 free、free 两次、use-after-free——大量 CVE 都来自这里。
路线 B:垃圾回收(Java/Go/Python):运行时定期扫描内存,回收不再用的对象。省心,但有运行时开销、暂停时间、内存膨胀。
路线 C:所有权(Rust):编译器在编译期分析"每个值什么时候不再需要",自动插入 drop。没有运行时开销,也不用担心忘 free——但你要遵守一套规则。
这套规则就是所有权。
2. 所有权的三条规则
Rust 官方总结:
- 每个值有一个"所有者"(owner);
- 同一时刻只能有一个所有者;
- 所有者离开作用域时,值被 drop(内存释放)。
看起来简单,但每一条都在改变你写代码的方式。
3. Move:移动语义
来看一段 C++ 里"看似正常"的代码在 Rust 里发生了什么:
let s1 = String::from("hello");
let s2 = s1;
println!("{}", s1); // ← 编译错误!
报错:use of moved value: s1。
为什么?因为 Rust 觉得 let s2 = s1 是**"把所有权从 s1 转移到 s2"**——不是拷贝。规则 2:一个值只能有一个所有者——所以 s1 之后不能再用。
在 C++ 里:s1 = s2 是深拷贝(默认调 copy constructor)。Rust 默认是 move。
这个差异是很多 C++ 程序员来 Rust 的最大障碍。
为什么 Rust 选 move:
- 明确性能开销——move 是零成本,拷贝可能很贵;
- 防 double free:如果两个变量都拥有同一个 String,作用域结束时会 drop 两次 → 内存崩溃;
- 强制思考"这份数据谁负责"——这是所有权的核心思想。
4. Copy:什么时候不 move
简单值不 move,它们 copy:
let x = 5;
let y = x;
println!("{}", x); // OK,x 还能用
为什么?因为 i32 实现了 Copy trait——赋值时自动按位复制。
哪些类型是 Copy 的:
- 所有整数、浮点、bool、char;
- 元组,如果所有字段都是 Copy 的;
- 数组,如果元素是 Copy 的。
哪些不是 Copy:
String、Vec、Box、HashMap——任何拥有堆分配的类型;- 自定义 struct 默认不是 Copy——除非你手动 derive。
规则:栈上的简单值是 Copy,堆上的数据不是。堆数据 move 一次是零成本(复制指针),但两个变量都拥有会 double free——所以必须 move。
5. Clone:显式深拷贝
如果你确实要复制一个 String 呢?用 .clone():
let s1 = String::from("hello");
let s2 = s1.clone();
println!("{}, {}", s1, s2); // 两个都能用
.clone() 是显式的深拷贝——花开销你能看见。这是 Rust 的哲学:贵的操作要显式写出来。
注意:新手最容易的错误是"编译器骂我就到处 clone 一下"——这是对付编译器的短期方案,长期代码质量会很差。大部分场景应该用 borrow(下一章讲),而不是 clone。
6. 所有权的传递:函数调用
函数参数也遵守所有权:
fn takes_ownership(s: String) {
println!("{}", s);
} // s 在这里被 drop
fn main() {
let s = String::from("hello");
takes_ownership(s);
println!("{}", s); // ← 编译错误!s 被移走了
}
关键点:把值传给函数,等于把所有权也交出去了。函数结束时值被 drop。
返回值 也可以传递所有权:
fn gives_ownership() -> String {
String::from("hello")
}
fn takes_and_gives_back(s: String) -> String {
s // 拿到、又送回去
}
let s1 = gives_ownership();
let s2 = takes_and_gives_back(s1);
这个模式很啰嗦——每个函数都要"接收 + 归还"。实际中我们几乎不这么写——用借用代替(下一章讲)。
7. 作用域与 Drop
变量离开作用域时被 drop:
{
let s = String::from("hello");
// s 是有效的
} // 这里 s 离开作用域,String 的内存被自动释放
内部机制:编译器在编译期看到 s 的作用域到哪结束,就在那里插入一段"释放堆内存"的代码。没有运行时 GC,只有静态插入的 free。
Drop trait 是这个机制的接口——你可以为自己的类型实现 Drop:
struct MyResource {
name: String,
}
impl Drop for MyResource {
fn drop(&mut self) {
println!("Dropping resource: {}", self.name);
}
}
fn main() {
let a = MyResource { name: String::from("A") };
{
let b = MyResource { name: String::from("B") };
} // 这里 b 被 drop
// main 结束时 a 被 drop
}
// 输出:
// Dropping resource: B
// Dropping resource: A
Drop 是"析构函数"——比 C++ 的更清晰,因为触发时机由编译器精确控制。
8. 一个例子:Vec 的所有权
let v = vec![1, 2, 3];
let v2 = v;
// println!("{:?}", v); // 错,v 被 move
for x in v2 {
println!("{}", x);
}
// println!("{:?}", v2); // 错!for 循环 move 了 v2
注意:for x in v2 会消费 v2——把它 move 进 for 循环。之后不能再用。
要不消费,用引用:
for x in &v2 { // 借用
println!("{}", x);
}
println!("{:?}", v2); // OK,v2 还在
for 循环 + 引用是最常见的组合。
9. 部分 move(partial move)
一个 struct 里的字段可以被单独 move 走:
struct Person {
name: String,
age: u32,
}
let p = Person { name: String::from("Alice"), age: 30 };
let n = p.name; // move 走 name
// let _ = p; // 错!p 已经不完整了
// println!("{}", p.name); // 错,name 被 move 走了
println!("{}", p.age); // OK,age 是 Copy,还在
部分 move 之后,struct 整体不能再用——但没被 move 的字段(Copy 类型)还能访问。
这个行为让 pattern matching 里的解构变得灵活:
match p {
Person { name, age } => {
// name 被 move 出,age 被 copy
}
}
10. 常见的错误模式
错误 1:在循环里 move
let v = vec![String::from("a"), String::from("b")];
for s in v { // v 被 move 进循环
process(s);
}
println!("{:?}", v); // 错!
修复:for s in &v 或者 for s in v.iter()。
错误 2:多次调用需要 self 的方法
struct Builder { name: String }
impl Builder {
fn set_name(self, name: String) -> Self { // self 拿走了
Self { name, ..self }
}
}
let b = Builder { name: String::from("a") };
let b2 = b.set_name(String::from("b"));
// let b3 = b.set_name(...); // 错!b 被 move
这是 builder pattern 的特点——每次调用 move 一次,链式往下走。用完之后原变量就不能用了。
错误 3:把可变引用传给要 move 的函数
fn consume(s: String) { }
let s = String::from("hello");
consume(s); // s 被 move
consume(s); // 错!s 已经不能用了
修复:consume(s.clone()) 或者改函数签名接受 &str。
错误 4:从 Vec 里"拿"某个元素
let v = vec![String::from("a")];
let x = v[0]; // 错!不能从 Vec 里直接 move 一个不是 Copy 的元素
修复:
let x = v[0].clone();(clone);let x = &v[0];(借用);let x = v.remove(0);(真的移除并拿走)。
11. 从函数返回而不是消费
一个 Rust 里常见的模式:不改参数,返回新值:
fn append_exclamation(mut s: String) -> String {
s.push('!');
s
}
let s = String::from("hello");
let s = append_exclamation(s); // 用同名变量遮蔽,看起来像修改
println!("{}", s); // "hello!"
这就是"值语义"编程——参数进去、返回值出来,没有偷偷改。
但一般我们还是用可变引用(下一章):
fn append_exclamation(s: &mut String) {
s.push('!');
}
let mut s = String::from("hello");
append_exclamation(&mut s);
看情况——改动小、常用 &mut;改动大或者要返回不同类型、用值语义。
12. Copy 和 Clone 的关系
Copy 是隐式的 memcpy——赋值时自动,你看不到:
let x = 5;
let y = x; // 隐式 copy,x 还在
Clone 是显式的方法——你要写 .clone():
let s = String::from("a");
let s2 = s.clone(); // 显式,可能很贵
规则:
- 一个类型是
Copy的,必然也是Clone的(可以隐式复制的更能显式复制); - 不是
Copy的可以是Clone的(比如 String); Copy只能给"简单的、只在栈上"的类型——String 之类的不能 Copy。
给自己的类型 derive:
#[derive(Copy, Clone)]
struct Point { x: f64, y: f64 }
// 现在 Point 是 Copy 的
#[derive(Clone)]
struct Person { name: String, age: u32 }
// Person 只是 Clone,不能 Copy(因为有 String 字段)
13. 所有权 vs 引用:什么时候用哪个
用所有权(值语义):
- 函数需要修改并返回这个东西;
- 函数需要存下来(比如放到自己的字段里);
- 函数需要消费这个东西(比如
into_iter); - 不需要之后再用原来的变量。
用引用(借用,下一章):
- 函数只是看一下、不改;
- 函数改一下、但之后原变量还要用;
- 短生命周期的临时操作。
一个直觉:看名字里有没有 into_、_move、consume——那些是消费型。其他大多数用引用。
14. 一个"啊哈"时刻的例子
看下面这段代码,你能理解发生了什么吗:
fn take(v: Vec<i32>) -> Vec<i32> {
// v 现在是我的了
let mut w = v;
w.push(4);
w // 我把它还给你
}
fn main() {
let v = vec![1, 2, 3];
let v = take(v); // "把 v 交出去,拿到新的 v 回来"
println!("{:?}", v); // [1, 2, 3, 4]
}
这个 take-and-return 模式在 Rust 里很常见。所有权像"接力棒"一样在函数间传递。
如果只是想改 v,用可变引用会更直观:
fn take(v: &mut Vec<i32>) {
v.push(4);
}
let mut v = vec![1, 2, 3];
take(&mut v);
println!("{:?}", v);
看情况选——这是 Rust 编程的核心决策。
15. 编译器如何检查所有权
这一切都是编译期完成的。编译器有一个内部叫做 borrow checker 的组件——它跟踪每个值的所有权:
- 变量被 move 之后标记"不可用";
- 引用被创建时记录生命周期;
- 违反规则时报错。
编译错误 = 潜在的 bug 被拦下来了。第一次写 Rust 你会觉得编译器烦得要命——但每一次报错,都是它替你抓住了 C++ 里可能崩溃或泄漏的 bug。
Rust 的口号:"如果编译过了,多半就是对的"——这不是玩笑,是真的。
16. 一些实用建议
不要一遇到 borrow error 就 clone。这是新手最常见的坏习惯。先问自己:真的需要拥有这个值吗?还是只是看一眼? 后者用引用。
结构体设计时想清楚谁拥有什么。像"这个 struct 拥有 name 还是引用 name"是个大决策——引用的话要引入生命周期(下一章)。新手建议先从"struct 拥有一切"起步——省心。
从"接手项目"读代码开始学:看别人的 Rust 代码是怎么处理所有权的,看多了就有直觉。tokio、serde、reqwest 的代码值得读。
善用 .into() 和 From trait:这些让"把一个类型转成另一个类型(并转移所有权)"的操作变得简洁。
接受这个学习曲线:新手前两周可能一直被编译器骂。这是正常的。撑过去之后你会突然发现"Rust 好像也没那么难"。
17. 一句话总结
所有权是 Rust 的"心跳":
- 规则:一个值一个 owner,owner 离开作用域时 drop;
- 默认 move:赋值、传参、返回都会转移所有权;
- 例外是 Copy 类型:整数、浮点等简单类型自动复制;
- 想显式复制:用
.clone(); - 想不复制也不转移:用引用(下一章);
- 不要滥用 clone——是短期解药、长期毒药。
理解了所有权,你就理解了 Rust 为什么能做到"没有 GC 也没有内存崩溃"。下一章讲借用——所有权的重要补充,让"函数看一眼数据、不消费"成为可能。