Move 语义：值在每个时刻只有一个主人

从这篇开始，我们进入 Rust 最核心、也最让初学者头疼的部分——所有权。Move 语义是所有权三件套里第一个登场的角色：一个值在同一时刻只能有一个主人，把值赋给别人、传进函数，主权就跟着转移。这篇解决的问题是：move 到底在移动什么、什么类型会 move、什么类型不会、编译器报 use of moved value 时违反了哪条规则。理解了 move，你对 Rust 内存模型的理解就过了一半。

一、为什么需要 move：不靠 GC 也能安全释放

C 的思路是程序员手动 free，Java 的思路是运行时扫描垃圾。Rust 选择第三条路：让编译器通过作用域静态推断每个值的释放点。要让这套推断成立，编译器必须精确跟踪「谁拥有这个值」——如果两个指针同时自认是主人，析构两次就炸了；如果没有主人，内存就泄漏。Move 语义因此不是语言洁癖，而是这套静态模型的必要条件：主变量移交主权之后，旧名字立刻失效，编译器就知道接下来只有一个析构点，释放逻辑从不确定性变成确定性。

所有权三条规则先背下来，后面所有错误都能往这三条上套：

第三条是新手最容易踩的：从其他语言来的人习惯于「传引用进去，变量还能继续用」，而 Rust 里传一个 String 进函数，出来之后那个变量就废了。

二、Move 的实际表现

move 并不在内存里复制大对象，对堆数据来说 move 通常只是把「指针、长度、容量」三件套从旧变量抄到新变量，旧的拷贝被标记无效——代价接近零。可以用编译错误直观感受规则的存在：

fn main() {
    let s1 = String::from("你好");
    let s2 = s1;                    // s1 的所有权转移给 s2
    // println!("{}", s1);          // 编译错误：use of moved value `s1`
    println!("{}", s2);
}

fn take(s: String) {
    println!("拿到 {}", s);
} // s 在这里被 drop

把 println!("{}", s1) 的注释去掉，编译器会给出 use of moved value 的错误，并告诉你 move 发生在哪一行。这种错误关心的是「编译期失效」，与运行时存不存在无关——即使你知道内存还在那儿，语言层面也不允许再碰，这正是编译期能保证不双重释放的原因，也是静态检查代价最低的地方。错误信息的完整性是 Rust 工具链的诚意：它不仅指出哪一行出了问题，还会画出两个相关位置之间的引用链，学会跟着它的指引读代码，排错速度会远超想象。

函数传参是隐式 move，函数返回值是反向 move。因此一个 String 在函数调用链里传来传去，每个时刻仍然只有一个主人，只是主人换了几次名字。

move 的另一个关键细节是「何时真正移动数据」。对 String 这类类型，move 只是搬动栈上的元数据（指针、长度、容量），堆上的字符序列纹丝不动；但如果你调用了 clone，堆数据才会被完整复制一遍。这也解释了为什么 Rust 里「赋值」看起来和别的语言一样轻——重活只发生在你显式要求复制的时候。

还有一点容易被忽略：move 发生在编译器认定的位置，而不是你想象的位置。比如把变量作为元组的一部分、塞进 Vec、放进 enum 的某个变体，都构成 move。识别所有 move 点是读代码的新技能，rust-analyzer 的内联提示会标出每个变量的存活范围，初期可以借助它训练直觉。

三、函数传参与返回值的组合

想让函数「用完归还」，标准做法是让函数把所有权返回回来：

fn make_louder(s: String) -> String {
    let mut s = s;
    s.push_str("！");
    s
}

fn main() {
    let original = String::from("你好");
    let louder = make_louder(original);
    println!("{}", louder);
}

这种「拿进去、改一下、还回来」的写法在简单场景可行，但参数一多就啰嗦：三个 String 进出，签名就要写六个位置。这就是为什么「引用与借用」一章存在——引用让你用值而不拿走所有权。可以先建立直觉：move 是默认且安全的，引用是人体工学上的优化。

顺带一提，返回所有权还有个常见退化场景：函数里构造了一个集合，返回它时不必担心效率——编译器对返回值有 move 语义保证，不会发生复制；配合内联与 LLVM 的实际优化，返回大对象通常和指针传递一样便宜。这一点和 C++ 早期「返回大对象必拷贝」的经验完全不同，从 C++ 转来的同学尤其要更新观念。

四、哪些类型不 move：Copy 的直觉

如果每个整数赋值都要 move，代码根本没法写。所以 Rust 有一类标量与定长类型实现了 Copy trait，赋值时按位复制，双方都可用：

判断依据很简单：类型内部若含有drop 语义或堆资源，就不能 Copy；纯栈上定长数据通常可以。你自己写的 struct 默认会 move，想让它 Copy 需要 #[derive(Copy, Clone)]，细节留到 Copy 与 Clone 一章展开。

一个反直觉的推论：Copy 类型作为函数参数传递时，函数内外两个名字都可用，因为复制了一份，互不影响。这也意味着 Copy 类型几乎不存在所有权烦恼，学所有权时拿 String 这种堆类型练手最直观，用 i32 练则会让你误以为规则不存在。

五、绕开 move 的三条合法路径

日常开发里，你不会总是想失去所有权，三条合法绕路要知道：

• 传引用：&s 借用，所有权不变，这是最常用的。
• 传克隆：s.clone() 显式复制，编译器闭眼放行，代价是一次分配。
• 传回所有权：如第三小节，函数把值返回给调用方。

判断该用哪条，看值会不会被修改、复制代价大不大、函数是否需要长期持有。新手常把 clone 当万能解药——编译能过，但高频路径上的 clone 会把性能拖回脚本语言的量级。看到 clone 时多问一句「这里是真的需要副本，还是只想用一下」。三个选择之间还可以用一张速查表来固定决策顺序：先问借用能否满足，再问返回所有权是否自然，最后才轮到克隆。

六、读懂数据流而不是背规则

move 语义真正的学习目标是建立「数据流」的阅读方式：看代码时不再问「这个变量是什么」，而是问「这个值现在在谁手上、它什么时候被释放」。初期不适应是正常的，坚持读错误信息而非绕过它，通常一两周就能形成反射，这个投资在整个 Rust 生涯里都会持续回报。配合 AI 工具逐条解释编译错误也能加速这个过程，Claude Code 使用指南 里有把编译器输出喂给模型做问答的实用技巧。等做到看一眼函数签名就能脑补所有权走向，后面借用与生命周期都会顺风很多。

延伸阅读

• 下一篇「引用与借用」讲解不改变所有权使用值的方法，是 move 语义的直接续集，建议紧接着读。
• 若想看清 move 后内存到底发生了什么，正则表达式精进 的高性能解析示例里有「用切片而非克隆传递数据」的完整演示，对照着看会更有体感。
• 等学完借用再回看本篇第三小节，你会发现自己能一眼判断哪个函数该传值、哪个该传引用，这种判断力是 Rust 工程师的基本功。