Rust所有权大揭秘：99%函数参数其实都应该用 &T 而不是 T

所有权是什么？为什么 Rust 要搞这么一套“规矩”？

Rust 这门硬核语言里最让人头疼、也最核心的概念——所有权（Ownership）。你可能会问：别的语言不是有垃圾回收（GC）吗？或者像 C/C++ 那样手动 malloc/free 不就行了？

Rust 偏偏要另辟蹊径，搞一套编译期就强制检查的内存管理规则，图啥？

因为上了面向对象OOP的贼船后，如果既要性能，又要安全，鱼和熊掌兼得者必是"奇葩"！

Rust 的所有权机制在程序编译阶段就帮你杜绝了内存泄漏、数据竞争、悬垂指针等一大堆低级错误，而且运行时零开销！也就是说，你的程序跑得飞快，还不用担惊受怕。听起来是不是很香？

但想用好它，就得先理解它的三大铁律：
每个值在任意时刻只能有一个所有者；
当所有者离开作用域（上下文Context），值就被自动释放；
如果你要把值传给别人，要么“移动”（move）所有权，要么“克隆”（clone）一份。

接下来，我们就用代码一步步来体验这套规则到底有多“较真”。

初尝所有权：从 Java 到 Rust，看似一样，实则天壤之别！

咱们先来看一段 Java 代码，非常简单：定义一个函数 own，接收一个字符串参数；在 main 里创建一个字符串变量 text，调用 own(text)，然后再打印 text。Java 程序员一看就懂，这有啥问题？text 是引用类型，传过去只是复制了引用，原变量毫发无损。但当你把这段逻辑“翻译”成 Rust，问题就来了！Rust 代码长这样：

fn own(_: String) {}

fn main() {
    let text: String = String::from("my text");
    own(text);
    println!("{}", text);
}

你一运行，编译器立马报错：error[E0382]: borrow of moved value: text。啥意思？就是说，text 这个变量在调用 own(text) 的时候，已经“移动”（move）给了函数 own，所有权转移了！

main 函数里再也无权使用 text 了。编译器还特别贴心地告诉你：你的 String 类型没有实现 Copy trait，所以不能自动复制，只能移动。

如果你非要在后面继续用 text，有两个办法：一是让函数 own 接收引用（&String），也就是“借用”；二是你主动调用 text.clone()，深拷贝一份传进去。

看，Rust 从一开始就逼你思考：这个数据到底归谁管？要不要共享？要不要复制？这种强制性的所有权转移，正是 Rust 内存安全的基石。

Clone vs Copy：别傻傻分不清，它们的性能代价天差地别！

那到底什么时候用 Clone，什么时候用 Copy 呢？

这里必须划重点！Clone 是一个 trait，调用它的 clone() 方法会执行深拷贝（deep copy），也就是把整个数据结构从堆上重新复制一份，非常耗内存和 CPU。
而 Copy 是另一个 trait，它代表类型可以被“按位复制”（bitwise copy），通常是栈上的简单数据，比如整数、布尔值、小元组等。一旦你给一个类型加上 #[derive(Copy, Clone)]，那么每次你把这个值传给函数或赋值给新变量时，Rust 都会自动复制一份，完全无需你手动调用 clone()。来看例子：

#[derive(Debug, Copy, Clone)]
struct Dummy {}

fn own(_: Dummy) {}

fn main() {
    let dummy = Dummy {};
    own(dummy);
    println!("{:?}", dummy);
}

这段代码完美运行，因为 Dummy 被标记为 Copy，传参时自动复制，原变量依然可用。但你要是给一个包含 String 的结构体加上 Copy，编译器会直接拒绝！因为 String 内部有堆分配的指针，简单按位复制会导致两个变量指向同一块内存，析构时 double free，程序崩溃。所以 Copy 只适用于“纯栈、无堆、无资源”的轻量类型。

记住：能用 Copy 就别用 Clone，Clone 是性能杀手，除非你真的需要独立副本。比如你处理大量坐标点 (f64, f64)，完全可以 Copy；但处理一个包含用户头像路径的用户对象，就必须小心 Clone，或者更推荐——用引用！

借用（Borrowing）才是日常开发的正确打开方式！

讲到这里，聪明的你肯定发现了：如果每次传参都要移动所有权或者深拷贝，那写代码岂不是寸步难行？别急，Rust 早就想到了——这就是“借用”（Borrowing）！借用就是传引用（&T），不转移所有权，也不复制数据，只是临时“借”一下。函数用完就还，原所有者继续持有。

这简直是日常开发的黄金法则！来看代码：

#[derive(Debug)]
struct Dummy {
    foo: String,
}

fn borrow(dummy: &Dummy) {
    println!("{:?}", dummy.foo);
}

fn main() {
    let dummy = Dummy { foo: String::from("Foo") };
    borrow(&dummy);
    println!("{:?}", dummy);
}

完美运行！main 函数里的 dummy 始终是唯一所有者，borrow 函数只是借来看一眼，用完就还。这种方式零拷贝、零移动，性能极高，而且安全。

99% 的函数参数其实都应该用 &T 而不是 T，除非你真的想“拿走”这个值（比如消费掉它，或者把它存进另一个结构体）。

Rust 的借用检查器（borrow checker）会在编译期确保：你不能同时存在可变借用和不可变借用，也不能在借用结束后还试图修改原值。这些规则听起来复杂，但一旦习惯，你会发现代码的健壮性直线上升。

想改数据？先学会“可变性”（Mutability）的三重门！

光能读还不够，很多时候我们得改数据啊！比如给用户打标签、更新游戏分数、处理传感器数据……Rust 说：可以改，但必须明确声明！在 Rust 里，变量默认是不可变的（immutable），要想修改，必须在声明时加上 mut 关键字。比如：

let mut dummy = Dummy { foo: String::from("Foo") };
dummy.foo = String::from("Bar");

这里 mut dummy 告诉编译器：“我允许这个变量被修改”。但光变量可变还不够，如果你要把这个可变性“借”给函数，函数参数也得声明为可变引用 &mut T。来看终极组合拳：

#[derive(Debug)]
struct Dummy {
    foo: String,
}

fn mutate(dummy: &mut Dummy) {
    dummy.foo = String::from("Bar");
    println!("Inside: {:?}", dummy.foo);
}

fn main() {
    let mut dummy = Dummy { foo: String::from("Foo") };
    mutate(&mut dummy);
    println!("Outside: {:?}", dummy.foo);
}

注意看三个关键点：
第一，main 里声明 dummy 时用了 mut；
第二，调用 mutate 时传的是 &mut dummy（可变引用）；
第三，函数 mutate 的参数类型是 &mut Dummy。

三者缺一不可！Rust 通过这三重保险，确保可变借用是受控的、排他的——在 &mut 借用期间，原变量和其他任何引用都不能访问。这从根本上杜绝了数据竞争（data race），让你在多线程环境下也能安心修改数据（当然，多线程借用有更复杂的规则，这里先不展开）。

记住：想改数据，就得“mut + mut + mut”，三位一体，天下无敌！

总结一张脑图：Rust 所有权行为全景速查表！

最后，咱们把前面所有内容浓缩成一张“行为速查表”，帮你快速决策：  
- 想转移所有权？直接传值（pass by value），但原变量不能再用。  
- 想复制一份？确保类型实现 Clone，然后显式调用 .clone()，注意性能开销。  
- 想自动复制？类型必须实现 Copy（仅限简单栈类型），无需手动 clone。  
- 想只读数据？传不可变引用 &T，安全又高效，日常首选。  
- 想修改数据？三步走：变量声明 mut、传参 &mut、函数参数 &mut T。  

Rust 的所有权模型看似繁琐，实则是用编译期的“麻烦”换运行期的“安心”。一旦你掌握了这套逻辑，写出来的代码不仅内存安全，还能自动获得并发安全的保障。这正是 Rust 能在系统编程、嵌入式、区块链、高性能服务等领域大放异彩的核心原因。