Rust：所有权
传统语言的内存管理要么依赖程序员手动管理（C/C++），要么依赖垃圾回收器（Java/Python）。Rust开创性地提出了第三条路：通过编译期的所有权系统自动管理内存，既保证内存安全，又避免运行时开销。
手动管理存在四大问题：
- 内存泄漏：忘记释放
- 悬垂指针：使用已释放的内存
- 重复释放：对同一内存多次释放
- 野指针：使用未初始化指针
垃圾回收的代价：
- 运行时性能开销
- 不可预测的暂停时间
- 额外的内存占用
Rust通过所有权系统在编译期解决所有内存安全问题，运行时零开销。
拷贝 & 移动
堆栈
在类似于 C/C++，Rust 这样的语言中，用户可以自己决定把数据存放在堆区或者栈区。
当在函数内部声明一个局部变量，就是把数据存放在了栈区，这个栈区内存会跟随着函数的结束而自动销毁。
Rust想把内存开在堆上时，可以使用Box这个智能指针：
fn heap_allocation() {
let x = 5; // 在栈区分配内存
let r = Box::new(42); // 在堆上分配整数
let arr = Box::new([1,2,3]); // 在堆上分配数组
// Box在栈上存储指针，指向堆上的实际数据
println!("堆上的值: {}", r);
} // 离开作用域时，堆内存自动释放
变量 r 在栈区，其内存储了一个指针，指针指向了堆区的内存，当变量 r 离开作用域销毁时，会把堆区的内存一起释放。
如图中，变量x存储的就是真实的数据5，而两个 Box 指针存储的是指向堆区的地址，可以通过地址找到对应的数据。
当函数heap_allocation调用结束，三个栈区的变量会随着函数一起被回收，但是堆区的数据怎么办？
在 C/C++ 中这种情况很容易发生，然是 Rust 杜绝了这种情况。
在 Rust 中，指针分为原生的指针 & 和· &mut 它们是非所有权指针，在编译器就会被借用检查器进行检查，防止内存泄露，具体机制后文会讲解。
另一种指针是智能指针，比如此处的 Box 就是一个智能指针。它使用了 RAII 机制，当 r 和 arr 离开作用域，会把对应的堆区内存一起回收。可以理解为智能制造是一种所有权指针，它决定了堆区数据的生命周期有多久，并保证其会被回收。
对于这种内存模型，还有一种问题就是堆区内存的拷贝问题，这会导致重复释放，或者内存泄露这样的问题。
例如以下情况：
最开始变量 r1 指向了堆区的数据，随后变量 r2 指向了相同的数据。
如果 r1 和 r2 都是智能指针，栈区被销毁的时候，堆区的 42 就会被分别释放两次，导致重复释放。
如果 r1 和 r2 都是非所有权指针，比如 &i32，栈区被销毁的时候，堆区的 42 不会发生销毁，导致内存泄露。
此时就需要 Rust 的拷贝机制 + 所有权机制一起配合了，Rust 保证上图的情况一定不会发生。
拷贝
对于普通变量，= 赋值默认就是拷贝：
fn simple_copy() {
let x = 5; // 普通整数
let y = x; // 发生拷贝，而非移动
println!("x: {}, y: {}", x, y); // 两者都有效
}
普通变量（整数、浮点数、字符、布尔值）的数据存储在栈上，拷贝成本低，并且会随着栈内存自动释放。
当函数 simple_copy 调用结束，由于两个变量都在栈区，会被正常销毁。
但是对于智能指针，就不能这么处理，否则会导致前文的重复释放问题，此时就要引入另一个概念：移动。
移动
当智能指针进行赋值或传参时，Rust会发生移动（move），即所有权的转移。
fn move_semantics() {
let r1 = Box::new(42);
let r2 = r1; // 所有权从r1转移到r2
// println!("{}", r1); // 编译错误：r1已失效
println!("{}", r2); // 正确：r2是新的所有者
}
如下图：
起初 r1 指向堆区内存，后续把 r1 赋值给 r2，它触发的不是拷贝，而是移动。此时 r2 指向堆区数据，但是 r1 失效了，被标记为 已移动。后续用户不能通过 r1 访问堆区变量，当函数调用结束，r1 也不会触发 RAII 销毁堆区的数据。
移动语义通过确保同一时刻只有一个所有者，防止了重复释放问题。
克隆
如果用户就是希望把堆区的内存拷贝一份，创建两个副本怎么办？
智能指针提供了 clone() 方法，它会进行深拷贝，把堆区的数据也拷贝一份。
fn box_clone() {
let r1 = Box::new(42);
let r2 = r1.clone(); // 调用clone方法，深拷贝
// 现在两个Box指向不同的堆内存
println!("r1: {}, r2: {}", r1, r2); // 都有效
}
内存模型如下图：
克隆不是把栈区的指针进行拷贝，而是对堆区的数据进行了深拷贝，随后两个指针指向了不同的堆区数据。
clone()方法会分配新的堆内存并复制数据，成本较高但安全
所有权
Rust的权限系统是理解所有权和借用的基础。通过精确控制变量对数据的访问权限，Rust在编译期就能保证内存安全。
Rust所有权系统建立在三条规则之上：
- 每个值都有且仅有一个所有者
- 所有权可以移动，但转移后原变量失效
- 所有者离开作用域时，值被自动释放
而为了实现这三条规则，引入了 RWO 三种权限，在编译期就会对权限进行检查。
Rust中的每个变量对其数据可能拥有三种基本权限：
- R (Read): 读取数据的权限，允许读取但不能修改数据
- W (Write): 修改数据的权限，允许修改数据的内容
- O (Own): 所有权权限，允许转移所有权或释放内存
变量的初始权限
变量在声明时会获得初始权限，这些权限直接决定了变量能进行什么操作。
不可变变量
当我们使用let声明一个不可变变量时：
- 获得
R权限：因为任何变量都应该能读取自己的值 - 获得
O权限：因为变量需要负责管理自己的内存 - 没有
W权限：因为是不可变的，所以不能修改
let x = Box::new(42);
println!("{}", x); // ✓ 使用R权限读取
// *x = 10; // ✗ 没有W权限，不能修改
let y = x; // ✓ 使用O权限转移所有权
可变变量
使用let mut声明的可变变量获得完整的RWO权限：
let mut x = 5;
println!("{}", x); // ✓ 使用R权限读取
*x = 10; // ✓ 使用W权限修改
let y = x; // ✓ 使用O权限转移所有权
不可变引用
不可变引用是Rust中最常见的借用形式。它指向的值仅有R权限：只能读取，不能修改
let x = 5;
let ref_x = &x;
println!("{}", ref_x); // ✓ 使用引用的R权限
// *ref_x = 10; // ✗ 指向的值没有W权限，不能修改
可变引用
相比于不可变引用，可变引用多出来 W 权限，可以修改指向的值。
let mut x = 5;
let ref_mut_x = &mut x;
println!("{}", ref_mut_x); // ✓ 使用引用的R权限
*ref_mut_x = 10; // ✓ 使用指向值的W权限
指针的双重权限
在Rust中，指针（引用）存在两层权限：
- 指针变量本身的权限：控制指针本身的读取、修改和所有权
- 指针指向内容的权限：控制对指针所指向数据的访问权限
let mut value = 42;
let ptr = &mut value;
// ptr本身的权限：
// R: 可以读取指针的地址
// O: 拥有指针本身的所有权
// *ptr（指向内容）的权限：
// R: 可以读取指向的值
// W: 可以修改指向的值R权限）
对于Rust的原生指针，是一种非所有权指针，它并不持有数据，只能读取或修改数据。也就是说当变量 ptr 离开作用域的时候，不会把指向的数据进行销毁，这是它与智能指针最大的区别。
fn pointer_dual_permissions() {
let mut value = 42;
let ptr = &mut value;
*ptr = 100;
}
当一个变量持有 O 权限，当离开作用域时，就会清理对应的内存。
以上代码中，对于数据 42，最开始 O 在 value 这个变量手中，ptr 引用到数据后没有转移走它的 O 权限。
当函数结束，对于栈区先进后出，ptr 先离开作用域，此时 ptr 自己销毁自己，但是不会销毁数据 42。而后 value 离开作用域，它持有数据 42 的所有权，就会把该数据一起销毁。
权限的动态变化
权限并非一成不变的，而是会随着创建引用，参数传递等行为发生变化。
不可变引用
let mut data = Box::new(42);
// *data: R W O - 初始拥有全部权限
let borrowed = &data;
// *data: R - 保留读权限，失去 W O 权限
// **borrowed: R - 指向内容只读
// *data = 100; // 错误：data失去W权限
// let moved = data; // 错误：data失去O权限
println!("{}", borrowed);
// borrowed使用结束
// *data重新获得 W O 权限
*data = 100; // 正确：权限已恢复
当创建不可变引用时：
- 原变量保留基本的
R权限，暂时失去W和O的权限 - 引用获得
R权限 - 引用结束后，原变量恢复权限
这是因为 borrow 是一个不可变引用，那么在这个引用存在期间，Rust 向用户保证数据不会发生任何改变，更不会被销毁或者转移。
为了实现这个特性，Rust 把原本 *data 的 W 和 O 权限给关闭了，防止用户通过 *data 来修改或者转移变量，保证内容不变且不会被转移。
可变引用
let mut value = Box::new(42);
// *value: R W O
let mut_ref = &mut value;
// *value: - (失去所有权限)
// **mut_ref: R W
// println!("{}", value); // 错误：没有 R 权限
**mut_ref = 100; // 正确：**mut_ref有W权限
// mut_ref使用结束
// *value重新获得 R W O 权限
当创建可变引用时：
- 原变量保留基本的
R权限，暂时失去RW和O的权限 - 引用获得
RW权限 - 引用结束后，原变量恢复权限
相比于不可变引用，可变引用多出 W 权限，对应的原变量也会暂时失去 W 权限。
引用赋值
前文提到了拷贝与移动两个概念，对于引用和可变引用，它们赋值时的行为是不同的。
不可变引用
let data = Box::new(42);
let ref1 = &data;
// **ref1: R
let ref2 = ref1; // 拷贝引用
// **ref2: R
// ref1和ref2都指向同一个数据
println!("{ref1} {ref2}"); // ✓ 正确：两个引用可以共存
以上代码中，ref2 对 ref1 进行了拷贝，两个引用同时持有对数据的 R 权限。
Rust 允许多个不可变引用同时读取一块数据。
可变引用
let mut value = Box::new(42);
// *value: R W O
let mut_ref1 = &mut value;
// **mut_ref1: R W
// *value: - (失去所有权限)
let mut_ref2 = mut_ref1; // 移动所有权
// **mut_ref2: R W
// **mut_ref1: - (失去所有权限)
println!("{}", mut_ref1); // ❌ 错误：mut_ref1已失效
println!("{}", mut_ref2); // ✓ 正确：只有mut_ref2可用
对于可变引用，通过 = 进行赋值时，发生移动，此时 **mut_ref1 失去了所有权限，不允许再使用。
Rust 同时只允许一个可变引用指向数据。
以上内容，其实揭示了Rust的一个核心规则：不允许一个数据同时存在“可变性”和“别名”。
如果一个数据是可变的，那么只有一个变量可以操作它。(独占读写)
- 创建一个可变引用，原变量会失去所有权限。
- 可变引用发生赋值，是发生了移动而非拷贝。
如果一个数据是不可变的，那多个变量可以同时进行读取。(共享只读)
- 创建一个不可变引用，原变量保留
R权限，失去WO。 - 不可变引用发生赋值，是发生了拷贝，此时多个引用指向同一数据。
重新借用
重新借用允许我们基于现有引用创建新的引用，而不需要访问原始数据：
let data = Box::new(42);
let data_ref = &data;
// 通过已有的可变引用重新借用
let reborrowed = & *data_ref ;
分析一下语法，data_ref 是指向数据的引用，*data_ref 先解引用获取数据，再通过&进行引用，这样reborrowed就引用到了相同的数据。
但是不觉得很别扭吗？先解引用，再进行引用，明明 let reborrowed = data_ref 就可以完成相同操作，为什么还需要重新借用？
重新借用主要是为了创建一个更短生命周期的引用，或者缩小引用的权限。
例如以下代码：
let mut data = Box::new(42);
let outer_ref = &mut data;
// *outer_ref: R W
{
let inner_ref = outer_ref;
// *outer_ref: - 失去所有权限
// *inner_ref: R W
println!("inner: {inner_ref}");
}
println!("outer: {outer_ref}"); // 错误: 没有任何权限
这段代码会报错，因为 outer_ref 是一个可变引用，先前讲过可变引用赋值时，进行的是移动。当inner_ref移动走了outer_ref的权限后，在内部作用域结束时，却不归还这个权限，所以外部的outer_ref就无法访问了。
如果想要实现这种，临时的更短生命周期的引用，就需要重新借用：
let mut data = Box::new(42);
let outer_ref = &mut data;
// *outer_ref: R W
{
let inner_ref = &mut *outer_ref; // 重新借用
// *outer_ref: - 失去所有权限
// *inner_ref: R W
println!("inner: {inner_ref}");
} // inner_ref 生命周期结束，*outer_ref 恢复 RW 权限
println!("outer: {outer_ref}"); // 正确
重新借用，会在新的引用生命周期结束时，恢复原引用的权限。
因为在 Rust 中，认为移动赋值这种行为，就是把我持有的数据交给你了，以后我不再使用了。所以使用 let inner_ref = outer_ref 创建引用，outer_ref 的权限不会恢复。
但是 &mut *outer_ref 在语义上明确了，我是在创建一个针对底部数据新的引用，我并没有表示我以后不再使用 outer_ref 了，所以当 inner_ref 生命周期结束，outer_ref 的所有权会被归还。
此外，重新借用还可以缩小所有权：
let mut data = Box::new(42);
let outer_ref = &mut data;
// *outer_ref: R W
{
let inner_ref = & *outer_ref; // 重新借用
// *outer_ref: R
// *inner_ref: R
println!("inner: {outer_ref}"); // 正确
println!("inner: {inner_ref}"); // 正确
} // inner_ref 生命周期结束，*outer_ref 恢复 RW 权限
println!("outer: {outer_ref}"); // 正确
原本的 outer_ref 是一个可变引用，在内部作用域，重新借用为了一个不可变引用。此时 *outer_ref 保留 R 失去 W，可以理解为在这一小段作用域内部，用户表明不会通过引用修改数据，缩小了权限。
函数调用时的权限
函数调用是 Rust 所有权系统的重要应用场景。根据传递的参数类型，Rust 会采用不同的权限处理策略。
移动
当传递具有所有权的类型（如 String、Vec、Box 等）时，会发生所有权转移：
fn take_ownership(inner: Box<i32>) {
println!("函数内: {}", inner);
// *inner 在这里拥有完整的所有权
} // inner 离开作用域，Box 被自动释放
fn main() {
let outer = Box::new(42);
// *outer: R W O
take_ownership(outer);
// *outer: - 所有权转移到函数内，失去所有权限
// println!("{}", outer); // 错误：outer 已失效
}
权限变化分析：
- 调用前：
*outer拥有R W O权限 - 调用时：
*outer失去所有权限，转移到函数参数*inner - 函数内：
*inner拥有R W O权限，可以自由使用和销毁 - 调用后：
inner连带着堆区的 Box 一起释放，*outer永久失效
如图：
当在 main 函数中调用 take_ownership，此时参数传递，原本outer指向堆区内存，移动给了inner，不能再通过outer访问堆区数据。
函数调用结束后，inner变量伴随着函数的栈区被释放，与此同时由于inner持有O权限，触发 inner 的 RAII 机制，把堆区的数据一并回收。
很多人此时去访问outer，就会发生错误，编译器不允许，因为outer调用完后已经失去了所有权限。
假如用户确实是把数据传进去后不在使用了，这个方案是可行的。但是如果还要继续使用，那么就要考虑其他方案了。
例如将变量重新返回：
fn take_ownership(inner: Box<i32>) -> Box<i32> {
println!("函数内: {}", inner);
inner
}
fn main() {
let mut outer = Box::new(42);
outer = take_ownership(outer);
println!("{}", outer); // 正确
}
它的所有权转移如图：
所有权在调用时移动到内部，在返回时又移动给外部，从始至终只有一个变量可以访问数据，并且堆区数据没有被销毁。
拷贝
对于拷贝的类型（如基本数据类型），会发生值拷贝而不是移动：
fn make_copy(x: i32) {
println!("函数内: {}", x);
// x 是栈上的值，离开作用域时自动清理
}
fn main() {
let num = 42;
make_copy(num); // num 的值被拷贝到函数内
println!("原值仍然可用: {}", num); // ✓ 正确！
}
权限变化分析：
- 调用前：
num拥有R O权限 - 调用时：
num的值被复制，函数参数x获得独立的副本 - 调用后：
num保持完整的R O权限 - 函数内：
x拥有独立的R O权限
如图：
这种情况下，内外两个变量从头到尾持有的都是不同的数据，不会出现数据的冲突。
借用
使用引用 & 来借用数据，不获取所有权，这是 Rust 中最常用的参数传递方式。
不可变借用
fn borrow_box(inner: &Box<i32>) {
println!("借用: {}", inner);
// inner 指向的值只有 R 权限，不能修改
}
fn main() {
let outer = Box::new(42);
borrow_box(&outer); // 传递不可变引用
println!("原值仍然可用: {}", outer); // 正确
}
权限变化分析：
调用前：*outer 拥有 RO 权限
调用时：*outer 保留 R 权限，暂时失去 O 权限
函数内：*inner 获得 R 权限
调用后：*outer 重新获得 O 权限
借用时，内部通过不可变引用拿到数据的权限。
当函数调用结束，inner跟随栈区销毁，由于是借用，不具有O的所有权，因此不会把堆区的数据一起销毁，而是把权限归还外部。
可变借用
fn borrow_box(inner: &mut Box<i32>) {
println!("借用: {}", inner);
**inner = 100;
}
fn main() {
let mut outer = Box::new(42);
borrow_box(&mut outer); // 传递可变引用
println!("原值仍然可用: {}", outer); // 正确
}
权限变化分析：
- 调用前：
*outer拥有RWO权限 - 调用时：
*outer保留R权限，暂时失去WO权限 - 函数内：
*inner获得R权限 - 调用后：
*outer重新获得WO权限
看起来可变借用形式传参，与不可变借用是相同的，只是多出来了 W 权限。
看似很合理，但是此处却有蹊跷，现在将代码改成以下写法：
fn borrow_box(inner_ref: &mut Box<i32>) {
println!("借用: {}", inner_ref);
**inner_ref = 100;
}
fn main() {
let mut outer = Box::new(42);
let outer_ref = &mut outer;
borrow_box(outer_ref); // 传递可变引用
println!("原值仍然可用: {}", outer); // 正确
}
先前说过，可变引用之间的赋值是移动，此处把 outer_ref 赋值到了 inner_ref，按理来说函数调用结束，outer_ref就会失效！
如果你不记得了，可以回看之前的这段代码：
let mut data = Box::new(42);
let outer_ref = &mut data;
// *outer_ref: R W
{
let inner_ref = outer_ref;
// *outer_ref: - 失去所有权限
// *inner_ref: R W
println!("inner: {inner_ref}");
}
println!("outer: {outer_ref}"); // 错误: 没有任何权限
这两个场景是类似的，都是需要在一个更小的作用域内部创建一个新的引用，但是函数调用结束后外部的引用所有权会恢复，而以上代码不会。
这是因为：函数引用传参时，不是直接赋值，而是重新借用。
以下两行代码是完全等效的：
borrow_box(outer_ref);
borrow_box(&mut *outer_ref);
因为 Rust 会隐式的把引用传参转变为重新借用，当内部函数调用完毕，外部的引用会恢复所有权。
复合类型的权限
到目前为止，我们主要分析的对象都是单个值（比如 Box<i32> 或 i32）。但在真实项目里，绝大多数数据结构都不是“单块变量”，而是复合类型：结构体、元组、数组、切片。
结构体
结构体的每一个字段都相当于一个变量，它们的权限是彼此独立的。
struct Person {
name: String,
age: i32,
}
fn struct_permissions() {
let mut person = Person {
name: String::from("Alice"),
age: 25,
};
let name_ref = &person.name;
// 借用 person.name: 失去 W + O
// person.age: 权限不受影响
person.age += 1; // 可以修改 age，因为它的权限没损失
// person.name.push_str(" Smith"); // 错误，name 被不可变借用，失去 W 权限
}
Rust 编译器能把借用精确到字段级，当你借用 person.name 时，只这一块字段的权限发生衰减，person.age 完全不受影响，这意味着 结构体允许局部可变，只要字段之间没有交叉冲突。
元组
元组其实就是匿名结构体，所以规则完全一致，各个位置的元素是互相独立的字段。
fn tuple_permissions() {
let mut tuple = (String::from("hello"), 42);
let str_ref = &tuple.0;
// tuple.0: 权限衰减至 R
// tuple.1: 权限完整
tuple.1 += 1; // 正确，独立字段
// 如果传给函数时整体借用：
fn get_first(t: &(String, i32)) -> &String {
&t.0
}
let first = get_first(&tuple);
// 此时 tuple 整体失去 W+O 权限
}
区别重点在最后一段：
&tuple.0：精准借用一个字段&(tuple)：整体借用
数组
数组和切片与结构体最大的不同在于：它们是连续存储。 一旦借走了一个元素，编译器就不能保证不会通过偏移方式访问到其它元素，于是采用了保守策略：借用一个元素时，整个数组失去所有权。
fn array_permissions() {
let mut arr = [1, 2, 3, 4, 5];
let first_ref = &mut arr[0]; // 可变借用第一个元素
// 整个数组失去 R W O 权限
// arr[1] += 1; // 错误，权限被整体锁定
// let second = arr[2]; // 同理，不能读取
*first_ref = 10; // 只能通过已有借用操作
}
数组在内存布局上是一片连续空间，arr[0] 和 arr[1] 物理上只差一个偏移。译器无法静态推断两个元素访问一定互不干扰，于是干脆剥夺整个数组的所有权，保证绝对安全。