4.认识所有权

4.1.什么是所有权

• 栈（Stack）与堆（Heap）
• 栈和堆都是代码在运行时可供使用的内存，但是它们的结构不同。
• 栈
• 后进先出
• 以放入值的顺序存储值
• 入栈
• 增加数据
• 出栈
• 移出数据
•  堆
• 在堆上分配内存的过程
• 想象一下去餐馆就座吃饭。当进入时，你说明有几个人，餐馆员工会找到一个够大的空桌子并领你们过去。如果有人来迟了，他们也可以通过询问来找到你们坐在哪。
• 入栈比在堆上分配内存要快
• 因为（入栈时）分配器无需为存储新数据去搜索内存空间；其位置总是在栈顶
• 在堆上分配内存则需要更多的工作，分配器必须首先找到一块足够存放数据的内存空间，并接着做一些记录为下一次分配做准备
• 访问堆上的数据比访问栈上的数据慢
• 因为必须通过指针来访问
• 处理器在处理的数据彼此较近的时候（比如在栈上）比较远的时候（比如可能在堆上）更高效
• 点菜的例子
• 跟踪哪部分代码正在使用堆上的哪些数据，最大限度的减少堆上的重复数据的数量，以及清理堆上不再使用的数据确保不会耗尽空间，这些问题正是所有权系统要处理的。一旦理解了所有权，你就不需要经常考虑栈和堆了，不过明白了所有权的主要目的就是管理堆数据，能够帮助解释为什么所有权要以这种方式工作。

• 所有权规则
✨
1. Rust 中的每一个值都有一个 所有者（owner）。
2. 值在任一时刻有且只有一个所有者。
3. 当所有者离开作用域，这个值将被丢弃。

• 变量作用域
• 变量的 作用域（scope）。作用域是一个项（item）在程序中有效的范围。
• 当 s 进入作用域时，它就是有效的。
• 这一直持续到它离开作用域为止。

• string 类型

• 内存与分配
• 对于 String 类型，为了支持一个可变，可增长的文本片段，需要在堆上分配一块在编译时未知大小的内存来存放内容。这意味着：
• 必须在运行时向内存分配器（memory allocator）请求内存。
• 当调用 String::from 时，它的实现 (implementation) 请求其所需的内存。这在编程语言中是非常通用的
• 需要一个当我们处理完 String 时将内存返回给分配器的方法。
• 第二部分实现起来就各有区别了，Rust 采取了一个不同的策略：内存在拥有它的变量离开作用域后就被自动释放
• 当 s 离开作用域的时候。当变量离开作用域，Rust 为我们调用一个特殊的函数。这个函数叫做 drop，在这里 String 的作者可以放置释放内存的代码。Rust 在结尾的 } 处自动调用 drop。
• 在更复杂的场景下代码的行为可能是不可预测的，比如当有多个变量使用在堆上分配的内存时
• 使用移动的变量与数据交互
• 两种不同的情况
• 1：因为整数是有已知固定大小的简单值，所以这两个 5 被压入了栈中
• 2：第二行可能会生成一个 s1 的拷贝并绑定到 s2 上。但事实并非如此
• 当我们将 s1 赋值给 s2，String 的数据被复制了，这意味着我们从栈上拷贝了它的指针、长度和容量。我们并没有复制指针指向的堆上数据
• 如果 Rust 这么做了，那么操作 s2 = s1 在堆上数据比较大的时候会对运行时性能造成非常大的影响
• 之前我们提到过当变量离开作用域后，Rust 自动调用 drop 函数并清理变量的堆内存。不过图 4-2 展示了两个数据指针指向了同一位置。这就有了一个问题：当 s2 和 s1 离开作用域，它们都会尝试释放相同的内存。这是一个叫做 二次释放（double free）的错误，也是之前提到过的内存安全性 bug 之一。两次释放（相同）内存会导致内存污染，它可能会导致潜在的安全漏洞。
• 为了确保内存安全，在 let s2 = s1; 之后，Rust 认为 s1 不再有效，因此 Rust 不需要在 s1 离开作用域后清理任何东西。看看在 s2 被创建之后尝试使用 s1 会发生什么；这段代码不能运行：
• 如果你在其他语言中听说过术语 浅拷贝（shallow copy）和 深拷贝（deep copy），那么拷贝指针、长度和容量而不拷贝数据可能听起来像浅拷贝。不过因为 Rust 同时使第一个变量无效了，这个操作被称为 移动（move），而不是叫做浅拷贝
• 这样就解决了我们的问题！因为只有 s2 是有效的，当其离开作用域，它就释放自己的内存，完毕。
• 另外，这里还隐含了一个设计选择：Rust 永远也不会自动创建数据的 “深拷贝”。因此，任何自动的复制都可以被认为是对运行时性能影响较小的。
• 作用域与赋值
• 当你给一个已有的变量赋一个全新的值时，Rust 将会立即调用 drop 并释放原始值的内存
• 因此原始的字符串立刻就离开了作用域。Rust 会在其上运行 drop 函数同时内存会马上释放。当结尾打印其值时，将会是 "ahoy, world!"。
• 使用克隆的变量与数据交互
• 如果我们 确实 需要深度复制 String 中堆上的数据，而不仅仅是栈上的数据，可以使用一个叫做 clone 的常用方法
• 当出现 clone 调用时，你知道一些特定的代码被执行而且这些代码可能相当消耗资源
• 只在栈上的数据：拷贝
• 整型，有效代码如下
• 这段代码似乎与我们刚刚学到的内容相矛盾：没有调用 clone，不过 x 依然有效且没有被移动到 y 中
• 原因是像整型这样的在编译时已知大小的类型被整个存储在栈上,所以拷贝其实际的值是快速的
• Rust 有一个叫做 Copy trait 的特殊注解，如果一个类型实现了 Copy trait，那么一个旧的变量在将其赋值给其他变量后仍然有效
• 关于 trait

功能	类比
约定一组行为	类似于 OOP 语言中的 “接口 interface”
多态支持	不同类型都可以实现同一个 trait，然后通过 trait 做统一处理
组合与扩展	通过 trait bounds 让泛型更强大，如 T: Clone + Debug
实现共享功能	类似于 “mixin”，一个 trait 也可以自带默认实现

• 任何一组简单标量值的组合都可以实现 Copy，任何不需要分配内存或某种形式资源的类型都可以实现 Copy
• 所有整数类型，比如 u32。
• 布尔类型，bool，它的值是 true 和 false。
• 所有浮点数类型，比如 f64。
• 字符类型，char。
• 元组，当且仅当其包含的类型也都实现 Copy 的时候。比如，(i32, i32) 实现了 Copy，但 (i32, String) 就没有。

• 所有权与函数
• 将值传递给函数与给变量赋值的原理相似，向函数传递值可能会移动或者复制，就像赋值语句一样

• 返回值与作用域
• 返回值也可以转移所有权

• 变量的所有权总是遵循相同的模式：将值赋给另一个变量时它会移动。当持有堆中数据值的变量离开作用域时，其值将通过 drop 被清理掉，除非数据被移动为另一个变量所有。

• 上述代码中
变量的所有权总是遵循相同的模式：将值赋给另一个变量时它会移动。当持有堆中数据值的变量离开作用域时，其值将通过 drop 被清理掉，除非数据被移动为另一个变量所有。
虽然这样是可以的，但是在每一个函数中都获取所有权并接着返回所有权有些啰嗦。如果我们想要函数使用一个值但不获取所有权该怎么办呢？如果我们还要接着使用它的话，每次都传进去再返回来就有点烦人了，除此之外，我们也可能想返回函数体中产生的一些数据。
• 但是这未免有些形式主义，而且这种场景应该很常见。幸运的是，Rust 对此提供了一个不用获取所有权就可以使用值的功能，叫做 引用（references）。
• 类比理解

操作类型	类比生活中的行为	结果
移动（Move）	把书送给朋友	你没有了，朋友有了
克隆（Clone）	复印一本书	你和朋友都有一本（但多耗资源）
借用（Reference）	借书给朋友看一眼	书还是你的，用完还你

• s1 没被移动，仍归 main 所有；
• 函数只是“借用”了 s1；
• 函数结束后，引用自动失效，但原值依然存在。

4.2.引用与借用

• 使用 & 引用相反的操作是 解引用（dereferencing），它使用解引用运算符 * 实现。我们将会在第八章遇到一些解引用运算符，并在第十五章详细讨论解引用。

• &s1 语法让我们创建一个指向值 s1 的引用，但是并不拥有它。因为并不拥有这个值，所以当引用停止使用时，它所指向的值也不会被丢弃。

4.2.1.可变引用

• 我们通过一个小调整就能修复示例 4-6 代码中的错误，允许我们修改一个借用的值，这就是 可变引用（mutable reference）：
• 你借给别人的书当然还是你的，但是别人也可以把它扯掉几页之后再还给你！
• 可变引用有一个很大的限制：如果你有一个对该变量的可变引用，你就不能再创建对该变量的引用。这些尝试创建两个 s 的可变引用的代码会失败：（你的一本书当然不能借给多个人）
• 笑死，给别人开空头支票可不就是容易出问题（概率上容易）
• 不能在同一时间多次将 s 作为可变变量借用
• Rustacean们：
这个限制的好处是 Rust 可以在编译时就避免数据竞争。数据竞争（data race）类似于竞态条件，它可由这三个行为造成：
• 两个或更多指针同时访问同一数据。
• 至少有一个指针被用来写入数据。
• 没有同步数据访问的机制。
数据竞争会导致未定义行为，难以在运行时追踪，并且难以诊断和修复；Rust 通过拒绝编译存在数据竞争的代码来避免此问题！
• 用大括号来创建一个新的作用域，以允许拥有多个可变引用，只是不能同时拥有
• 我把书借给你，但是你只能在教室看，你离开教室了我借给别人当然没问题！
• Rust 在同时使用可变与不可变引用时也强制采用类似的规则
• 不能在拥有不可变引用的同时拥有可变引用
• 不可变引用的借用者可不希望在借用时值会突然发生改变！然而，多个不可变引用是可以的
• 这种情况可以：
• 因为它们的作用域没有重叠，所以代码是可以编译的

4.2.2.悬垂引用

• 在具有指针的语言中，很容易通过释放内存时保留指向它的指针而错误地生成一个悬垂指针（dangling pointer）—— 指向可能已被分配给其他用途的内存位置的指针。在 Rust 中编译器确保引用永远也不会变成悬垂引用：当你拥有一些数据的引用，编译器确保数据不会在其引用之前离开作用域。

• 因为 s 是在 dangle 函数内创建的，当 dangle 的代码执行完毕后，s 将被释放。不过我们尝试返回它的引用。这意味着这个引用会指向一个无效的 String，这可不对！Rust 不会允许我们这么做。

• 解决办法

• 在任意给定时间，要么只能有一个可变引用，要么只能有多个不可变引用。

• 引用必须总是有效的。

4.2.3.Slice类型

• 以一个例子看看 Slice 解决了什么问题：“编写一个函数，该函数接收一个用空格分隔单词的字符串，并返回在该字符串中找到的第一个单词。如果函数在该字符串中并未找到空格，则整个字符串就是一个单词，所以应该返回整个字符串。”

• 字符串 Slice