Rust 系列

🎀Rust编程语言入门教程（一）安装Rust🚪
🎀Rust编程语言入门教程（二）hello_world🚪
🎀Rust编程语言入门教程（三） Hello Cargo🚪
🎀Rust编程语言入门教程（四）猜数游戏：一次猜测🚪
🎀Rust编程语言入门教程（五）猜数游戏：生成、比较神秘数字并进行多次猜测🚪
🎀Rust编程语言入门教程 （六）变量与可变性🚪
🎀Rust编程语言入门教程 （七）函数与控制流🚪

引言

在现代编程语言中，内存管理和性能优化一直是开发者面临的挑战。许多语言依赖垃圾回收机制（GC）来自动管理内存，但这种方式可能会引入运行时开销。另一些语言则要求程序员手动管理内存，这虽然提供了更高的性能，但也容易导致内存泄漏、悬空指针等问题。Rust 通过其独特的所有权系统，提供了一种无需垃圾回收即可保证内存安全的解决方案。所有权机制通过一系列编译时规则，确保程序在运行时不会出现内存泄漏或数据竞争等问题。本文将深入探讨 Rust 的所有权机制，包括栈（Stack）和堆（Heap）内存的管理，以及如何通过移动（Move）、克隆（Clone）和复制（Copy）等操作安全地处理数据。

一、什么是所有权?

所有权是 Rust 最独特的特性，它让Rust无需GC（垃圾回收）就可以保证内存安全。
Rust的核心特性就是所有权。

所有程序在运行时都必须管理它们使用计算机内存的方式。
有些语言有垃圾收集机制，在程序运行时，它们会不断地寻找不再使用的内存。比如C#、Java。
在其他语言中，程序员必须显式地分配和释放内存。比如 C、C++。

Rust采用了第三种方式：
内存是通过一个所有权系统来管理的，其中包含一组编译器在编译时检查的规则。
当程序运行时，所有权特性不会减慢程序的运行速度。

二、Stack(栈内存) vs Heap (堆内存)

在像 Rust 这样的系统级编程语言里，一个值是在 stack 上还是在 heap 上对语言的行为和你为什么要做某些决定是有更大的影响的。

在你的代码运行的时候，Stack 和 Heap 都是你可用的内存，但他们的结构很不相同。

Stack 按值的接收顺序来存储，按相反的顺序将它们移除(后进先出，LIFO)

• 添加数据叫做压入栈
• 移除数据叫做弹出栈

所有存储在 Stack 上的数据必须拥有已知的固定的大小。
编译时大小未知的数据或运行时大小可能发生变化的数据必须存放在 heap上。

Heap 内存组织性差一些:

• 当你把数据放入 heap时，你会请求一定数量的空间。
• 操作系统在 heap 里找到一块足够大的空间，把它标记为在用，并返回一个指针，也就是这个空间的地址。
• 这个过程叫做在 heap 上进行分配，有时仅仅称为“分配。

把值压到 stack 上不叫分配。因为指针是已知固定大小的，可以把指针存放在 stack上。但如果想要实际数据，你必须使用指针来定位。

把数据压到 stack上要比在 heap 上分配快得多。因为操作系统不需要寻找用来存储新数据的空间，那个位置永远都在 stack 的顶端。在 heap 上分配空间需要做更多的工作: 操作系统首先需要找到一个足够大的空间来存放数据，然后要做好记录方便下次分配。

（一）访问数据

访问 heap 中的数据要比访问 stack 中的数据慢，因为需要通过指针才能找到 heap 中的数据。
对于现代的处理器来说，由于缓存的缘故，如果指令在内存中跳转的次数越少，那么速度就越快。

• 如果数据存放的距离比较近，那么处理器的处理速度就会更快一些 (stack上)。
• 如果数据之间的距离比较远，那么处理速度就会慢一些 (heap上)。
• 在 heap 上分配大量的空间也是需要时间的。

（二）函数调用

当你的代码调用函数时，值被传入到函数 (也包括指向 heap的指针)。函数本地的变量被压到 stack上。当函数结束后，这些值会从stack上弹出。

（三）所有权解决的问题

• 跟踪代码的哪些部分正在使用 heap 的哪些数据
• 最小化 heap 上的重复数据量
• 清理 heap 上未使用的数据以避免空间不足，
  一旦你懂的了所有权，那么就不需要经常去想 stack 或 heap 了。但是知道管理 heap 数据是所有权存在的原因，这有助于解释它为什么会这样工作。

三、所有权规则

• 每个值都有一个变量，这个变量是该值的所有者。
• 每个值同时只能有一个所有者。
• 当所有者超出作用域(scope)时，该值将被删除。

四、理解所有权规则(String 类型举例)

String 比那些基础标量数据类型更复杂。
字符串字面值：程序里手写的那些字符串值。它们是不可变的。
Rust 还有第二种字符串类型：String。在 heap 上分配。能够存储在编译时未知数量的文本。

（一）创建 String 类型的值

• 可以使用 from 函数从字符串字面值创建出 String 类型。
  let s = String::from(“hello”);
  “ :: ” 表示 from 是 String 类型下的函数。
• 这类字符串是可以被修改的。
• 为什么 String 类型的值可以修改，而字符串字面值却不能修改,因为它们处理内存的方式不同。

（二）内存和分配

字符串字面值，在编译时就知道它的内容了，其文本内容直接被硬编码到最终的可执行文件里。速度快、高效，是因为其不可变性。
String 类型，为了支持可变性，需要在 heap 上分配内存来保存编译时未知的文本内容:

• 操作系统必须在运行时来请求内存，这步通过调用 String::from 来实现
• 当用完String之后，需要使用某种方式将内存返回给操作系统。这步，在拥有GC的语言中，GC会跟踪并清理不再使用的内存。

没有GC，就需要我们去识别内存何时不再使用，并调用代码将它返回。
如果忘了，那就浪费内存；
如果提前做了，变是就会非法；
如果做了两次，也是Bug。必须一次分配对应一次释放。

Rust采用了不同的方式：对于某个值来说，当拥有它的变量走出作用范围时，内存会立即自动的交还给操作系统。会调用 drop函数。

（三）变量和数据交互的方式:移动(Move)

多个变量可以与同一个数据使用一种独特的方式来交互。
let x= 5;
let y = X;

整数是已知且固定大小的简单的值，这两个5被压到了stack中。

String版本

let s1 = String::from(“hello”);
let s2 = s1;

① 一个String由3部分组成:

• 指向存放字符串内容的内存的指针
• 长度
• 容量
  上面这些东西放在 stack 上。
  存放字符串内容的部分在 heap上
  长度 len，就是存放字符串内容所需的字节数。
  容量 capacity 是指 String 从操作系统总共获得内存的总字节数。
  

let s1 = String::from(“hello”);
let s2 = s1;

当把 s1 赋给 s2，String 的数据被复制了一份
在 stack上复制了一份指针、长度、容量，并没有复制指针所指向的 heap上的数据。

当变量离开作用域时，Rust 会自动调用 drop 函数，并将变量使用的 heap 内存释放。
当s1、s2离开作用域时，它们都会尝试释放相同的内存:
二次释放(double free) bug

为了保证内存安全:
Rust 没有尝试复制被分配的内存。
Rust 让 s1 失效。当 s1 离开作用域的时候，Rust 不需要释放任何东西。
试试看当 s2 创建以后再使用 s1是什么效果。

cargo run 运行，会发现报错。借用了已经移动的s1。

② 浅拷贝(shallow copy) 深拷贝(deep copy)

你也许会将复制指针、长度、容量视为浅拷贝，但由于 Rust 让 s1失效了，所以我们用一个新的术语: 移动(Move)。
隐含的一个设计原则: Rust不会自动创建数据的深拷贝。就运行时性能而言，任何自动赋值的操作都是廉价的。

s1 赋值给 s2 之后就失效了。

⑤ 克隆（Clone）

如果真想对 heap 上面的 String 数据进行深度拷贝，而不仅仅是 stack上的数据，可以使用clone方法。主要针对堆上面的数据。

（四）stack上的数据：复制

Copy trait，可以把trait 简单理解为接口。可以用于像整数这样完全存放在 stack 上面的类型。
如果一个类型实现了Copy 这个 trait，那么旧的变量在赋值后仍然可用。
如果一个类型或者该类型的一部分实现了Drop trait，那么Rust 不允许让它再去实现 Copy trait 了。

x 是整数类型，在编译的时候就已经确定了它的大小，并且能将数据完整地存储在stack 中。而对这些数的复制操作，都是非常快速的。在创建变量y之后，我们没有任何理由阻止变量x继续保持有效。换句话而言，对于这些类型，深拷贝和浅拷贝没有区别的。调用Clone（）方法不会与直接的浅拷贝有任何行为上的区别。

（五）一些拥有 Copy trait 的类型

• 任何简单标量的组合类型都可以是 Copy 的；
• 任何需要分配内存或某种资源的都不是 Copy 的；

一些拥有 Copy trait 的类型:

• 所有的整数类型，例如U32；
• bool
• char
• 所有的浮点类型，例如f64
• Tuple(元组)，如果其所有的字段都是Copy的
  ( i32, i32) 是
  ( i32, String) 不是

五、所有权与函数

在语义上，将值传递给函数和把值赋给变量是类似的：将值传递给函数将发生移动或复制。

函数在返回值的过程中同样也会发生所有权的转移。

一个变量的所有权总是遵循同样的模式：

• 把一个值赋给其它变量时就会发生移动
• 当一个包含 heap 数据的变量离开作用域时，它的值就会被 drop 函数清理，除非数据的所有权移动到另一个变量上了。
  

如何让函数使用某个值，但不获得其所有权?

Rust 有一个特性叫做 引用 (Reference) 这个我们下一节再讲！

总结

Rust 的所有权系统是其最核心的特性之一，它通过一系列严格的编译时规则，确保了内存的安全性和高效性。通过栈和堆的管理，Rust 能够在运行时快速分配和释放内存，同时避免了垃圾回收机制带来的性能开销。所有权规则确保每个值在任何时刻只有一个所有者，并在所有者超出作用域时自动清理内存。通过移动（Move）、克隆（Clone）和复制（Copy）等机制，Rust 提供了灵活且高效的内存管理方式。这些特性不仅使得 Rust 成为一种适合系统编程的语言，也为开发者提供了一种安全、高效的编程范式。掌握所有权机制，是深入理解 Rust 编程语言的关键一步。