所有权三原则
核心概念
所有权(Ownership)是 Rust 最核心的特性,它让 Rust 在没有垃圾回收的前提下实现了内存安全。整个所有权系统建立在三条简单的规则之上,编译器在编译期检查这些规则,违反任何一条都会导致编译错误。
规则一:每个值都有且只有一个所有者
在 Rust 中,每个值在任意时刻都有且只有一个变量作为它的"所有者"。不存在两个变量同时拥有同一个值的情况。
fn main() {
// s1 是字符串 "hello" 的所有者
let s1 = String::from("hello");
// 所有权从 s1 转移到 s2(移动语义)
let s2 = s1;
// 此时 s2 是所有者,s1 不再有效
println!("{}", s2); // 可以使用 s2
// println!("{}", s1); // 编译错误:s1 的所有权已经转移
}规则二:同一时间只能有一个所有者
当所有权从一个变量转移到另一个变量时,原变量立即失效。这杜绝了"两个变量同时拥有同一份堆数据"的情况,从根源上避免了双重释放(double free)问题。
fn main() {
let v1 = vec![1, 2, 3];
// 赋值导致所有权转移
let v2 = v1;
// v1 不再有效,v2 是唯一的所有者
// 传参也会转移所有权
let v3 = vec![4, 5, 6];
take_ownership(v3);
// v3 不再有效,所有权已转移到函数参数中
println!("{:?}", v2);
// println!("{:?}", v3); // 编译错误:值已移动
}
fn take_ownership(data: Vec<i32>) {
// data 是这个 Vec 的所有者
println!("接收到: {:?}", data);
// 函数结束时 data 被销毁
}规则三:当所有者离开作用域,值被销毁
变量离开其所在的作用域时,Rust 自动调用 drop 函数释放该变量拥有的资源。不需要手动释放内存,也不需要垃圾回收器。
fn main() {
{
let s = String::from("hello");
// s 在这个作用域内有效
println!("{}", s);
} // s 离开作用域,String 的内存被自动释放
// println!("{}", s); // 编译错误:s 已不存在
}所有权转移的场景
fn main() {
// 场景一:变量赋值
let a = String::from("data");
let b = a; // 所有权从 a 转移到 b
// a 不再可用
// 场景二:函数传参
let c = String::from("param");
process(c); // 所有权转移到函数参数
// c 不再可用
// 场景三:函数返回值
let d = create(); // 所有权从函数返回给 d
println!("{}", d);
// 场景四:集合操作
let mut items = vec![String::from("a"), String::from("b")];
let first = items.remove(0); // 所有权从 Vec 转移到 first
println!("取出: {}", first);
println!("剩余: {:?}", items);
}
fn process(s: String) {
println!("处理: {}", s);
// s 在函数结束时被销毁
}
fn create() -> String {
let s = String::from("新创建的");
s // 所有权转移给调用者
}Copy 类型的例外
基本类型(整数、浮点数、布尔值、字符)实现了 Copy trait,赋值时是复制而不是移动,原变量仍然可用。
fn main() {
// 基本类型:复制,不是移动
let x = 42;
let y = x; // x 被复制了一份给 y
println!("x = {}, y = {}", x, y); // 两个都可用
let a = true;
let b = a; // 复制
println!("a = {}, b = {}", a, b);
let c = 3.14;
let d = c; // 复制
println!("c = {}, d = {}", c, d);
// 堆分配类型:移动,不是复制
let s1 = String::from("hello");
let s2 = s1; // 移动
// println!("{}", s1); // 编译错误
// 元组:如果所有元素都是 Copy 的,元组也是 Copy 的
let t1 = (1, 2.0, true);
let t2 = t1; // 复制
println!("{:?}, {:?}", t1, t2); // 两个都可用
// 元组:如果包含非 Copy 类型,就是移动
let t3 = (1, String::from("hello"));
let t4 = t3; // 移动
// println!("{:?}", t3); // 编译错误
println!("{:?}", t4);
}| 行为 | Copy 类型 | 非 Copy 类型 |
|---|---|---|
赋值 let b = a | 复制,a 仍可用 | 移动,a 不可用 |
传参 foo(a) | 复制,a 仍可用 | 移动,a 不可用 |
| 内存位置 | 栈上 | 通常涉及堆 |
| 释放 | 无需特殊处理 | 离开作用域时 drop |
| 常见类型 | i32、f64、bool、char | String、Vec、Box |
为什么需要所有权
所有权系统解决了其他语言中常见的内存问题:
fn main() {
// 问题一:双重释放 —— Rust 通过所有权转移杜绝
let s1 = String::from("hello");
let s2 = s1; // s1 失效,只有 s2 会释放内存
// 不可能两个变量都去释放同一块内存
// 问题二:悬垂指针 —— Rust 不允许引用超过数据的生命周期
// fn dangling() -> &String { // 编译错误
// let s = String::from("hello");
// &s // s 在函数结束时被释放,引用会悬垂
// }
// 问题三:内存泄漏 —— Rust 在所有者离开作用域时自动释放
{
let data = vec![1, 2, 3, 4, 5];
// 使用 data...
} // data 自动释放,不会泄漏
println!("{}", s2);
}基本示例
用所有权规则管理资源的完整示例:
struct FileHandle {
name: String,
content: String,
}
impl FileHandle {
// 创建时获得所有权
fn new(name: &str) -> FileHandle {
println!("[打开] {}", name);
FileHandle {
name: name.to_string(),
content: String::new(),
}
}
// &mut self:借用,不转移所有权
fn write(&mut self, data: &str) {
self.content.push_str(data);
println!("[写入] {} -> '{}'", self.name, data);
}
// &self:借用,不转移所有权
fn read(&self) -> &str {
&self.content
}
}
// 实现 Drop trait:所有者离开作用域时自动调用
impl Drop for FileHandle {
fn drop(&mut self) {
println!("[关闭] {}", self.name);
}
}
fn process_file(mut file: FileHandle) {
// file 获得了所有权
file.write("被处理函数写入的内容");
println!("内容:{}", file.read());
// 函数结束时 file 被销毁,自动调用 drop
}
fn main() {
let mut f1 = FileHandle::new("config.txt");
f1.write("key=value");
println!("读取:{}", f1.read());
// 所有权转移给函数
process_file(f1);
// f1 不再可用,FileHandle 已在 process_file 结束时关闭
{
let f2 = FileHandle::new("temp.txt");
// f2 在作用域结束时自动关闭
}
println!("程序继续...");
}常见问题
问题一:为什么 Rust 不像 Java/Go 那样用垃圾回收?
垃圾回收有运行时开销(暂停、内存占用、不可预测的延迟)。Rust 的所有权系统在编译期就确定了每个值什么时候释放,运行时零开销,释放时机完全可预测。
问题二:所有权转移后还想用原来的变量怎么办?
三种方式:用 .clone() 创建深拷贝、用引用(&T 或 &mut T)借用而不转移所有权、让函数返回值把所有权还回来。
问题三:所有三条规则是编译器检查的还是运行时检查的?
完全是编译期检查。如果代码违反所有权规则,程序根本无法编译通过。编译通过的代码不会出现所有权相关的内存错误。
问题四:为什么基本类型可以复制而 String 不行?
基本类型(如 i32)只在栈上存储,大小固定且很小,复制成本极低。String 包含堆上的动态数据,浅拷贝会导致两个变量指向同一块堆内存,产生双重释放问题。
适用场景
- 资源管理:文件句柄、网络连接、数据库连接等通过所有权自动释放
- 内存安全:编译器保证没有悬垂指针、双重释放、使用已释放的内存
- 线程安全:所有权规则天然防止数据竞争
- API 设计:通过函数参数的所有权/借用选择来表达接口意图
注意事项
- 每个值只有一个所有者,赋值和传参会转移所有权(非 Copy 类型)
- Copy 类型赋值时是复制,原变量仍然有效
- 所有者离开作用域时值被自动释放
- 如果需要保留原变量,用
.clone()或引用 - 所有权规则是编译期检查,没有运行时开销
- 不要为了避免所有权转移而到处
.clone(),优先考虑使用引用
总结
Rust 所有权系统建立在三条规则上:每个值有且只有一个所有者、同一时间只能有一个所有者、所有者离开作用域时值被销毁。这三条规则让编译器能在编译期确定每个值的生命周期和释放时机,实现了无垃圾回收的内存安全。赋值和传参默认会转移所有权(移动语义),实现了 Copy trait 的基本类型除外。所有权系统是 Rust 的核心特性,理解它是掌握 Rust 编程的第一步。