Rust 核心解密：为什么你的变量“消失”了？一文读懂所有权机制

摘要：在 Rust 的世界里，赋值不仅仅是复制，更是一场所有权的交接。本文将带你穿透栈与堆的迷雾，揭开 Rust 内存安全的终极秘密——所有权（Ownership）。

如果你刚从 Java、Python 或 JavaScript 转向 Rust，你可能会遇到一个让人抓狂的现象：明明刚才还存在的变量，怎么突然就不能用了？

1
2
3

let s1 = String::from("Hello");
let s2 = s1;
println!("{}", s1); // ❌ 编译错误！value borrowed here after move

这并非 Bug，而是 Rust 设计哲学的基石——所有权（Ownership）。今天，我们就从内存管理的底层逻辑出发，彻底搞懂 Rust 是如何管理资源的。

01. 栈与堆：内存的双面舞台

要理解所有权，首先得知道数据住在哪里。现代计算机内存主要划分为几个区域，其中与我们编程最相关的是栈（Stack）和堆（Heap）。

栈（Stack）：
- 特点：操作极快，只需移动栈顶指针。
- 存储内容：固定尺寸的值（如 i32, u64, 布尔值）。
- 生命周期：与函数调用帧（Frame）绑定。函数结束，栈帧弹出，数据自动销毁。
堆（Heap）：
- 特点：空间大但分配/回收较慢，需要手动或自动管理。
- 存储内容：非固定尺寸的值（如 String, Vec）。
- 访问方式：栈上保存一个指向堆内存地址的指针。

💡 关键洞察：Rust 中的复杂类型（如 String），其实是由“栈上的指针+长度+容量”和“堆上的实际数据”两部分组成的。

02. 变量的可变性与 Shadowing

在 Rust 中，变量默认是**不可变（Immutable）**的。

1 2	let x = 5; x = 6; // ❌ 错误：cannot assign twice to immutable variable

这种设计是为了减少低级 Bug。如果确实需要修改，必须显式声明 mut：

1 2	let mut x = 5; x = 6; // ✅ 正确

什么是 Shadowing（遮蔽）？

你可以重新定义一个同名变量，新变量会“遮蔽”旧变量。这不同于修改，它是创建了一个全新的绑定。

1
2
3

let x = 5;
let x = x + 1; // ✅ 合法，新的 x 遮蔽了旧的 x
let x = "Spaces"; // ✅ 甚至可以是不同类型

Shadowing vs Mutability:

mut 是在原内存位置上修改值。
Shadowing 是创建新变量，允许改变类型，且不需要 mut。

03. 核心概念：所有权三原则

Rust 通过以下三条规则来管理内存，无需垃圾回收器（GC）：

Rust 中的每一个值都有一个所有者（Owner）。
同一时刻，一个值只能有一个所有者。
当所有者离开作用域（Scope）时，该值将被丢弃（Drop）。

这就是著名的 RAII（Resource Acquisition Is Initialization） 机制在 Rust 中的体现。

04. 移动（Move）vs 复制（Copy）

这是初学者最容易混淆的地方。为什么 i32 可以随意赋值，而 String 不行？

场景一：栈上数据的复制（Copy）

对于固定尺寸的基本类型（实现 Copy trait 的类型），赋值时会发生深拷贝。

1
2
3

let a = 10u32;
let b = a; // 栈上复制了一份 10
println!("{}, {}", a, b); // ✅ 输出: 10, 10

包括：所有整数类型、布尔值、浮点数、字符、由上述类型组成的元组和数组。

场景二：堆上数据的移动（Move）

对于存储在堆上的数据（如 String），赋值时只复制栈上的指针，并将所有权转移给新变量，原变量失效。

let s1 = String::from("Hello");
let s2 = s1; 
// s1 的所有权移动给了 s2
// s1 现在处于“无效”状态，编译器禁止再次使用
println!("{}", s2); // ✅
println!("{}", s1); // ❌ 编译错误

🤔 为什么这样设计？
如果 s1 和 s2 都指向同一块堆内存，当它们离开作用域时，会尝试释放同一块内存两次（Double Free），导致严重的安全漏洞。Rust 通过“移动”语义，确保同一时刻只有一个变量负责释放内存。

如何保留所有权？

如果你既想传递数据，又想保留原变量的使用权，有两种方法：

克隆（Clone）：显式复制堆上的数据（性能开销大）。
1
let s2 = s1.clone();
借用（Borrow）：使用引用 &（下一节课重点）。
1
let s2 = &s1;

05. 函数中的所有权

函数参数同样遵循所有权规则。当你把变量传入函数时，所有权也随之移动。

fn take_ownership(s: String) {
    println!("{}", s);
} // s 在这里离开作用域，被 drop

fn main() {
    let s1 = String::from("Hello");
    take_ownership(s1); 
    // println!("{}", s1); // ❌ 错误：s1 的所有权已移入函数
}

如果想让函数返回后还能使用数据，可以将所有权移回：

fn give_back(s: String) -> String {
    s
}

fn main() {
    let s1 = String::from("Hello");
    let s1 = give_back(s1); // 接收返回的所有权
    println!("{}", s1); // ✅
}