认识所有权(ownership)

栈和堆
什么是所有权
引用与借用
- 可变引用
- 悬垂引用
Slice类型
- 字符串slice
  - 字符串字面值就是slice
  - 字符串slice值作为参数
- 其他类型的slice

栈和堆

栈中的所有数据都必须占用已知且固定的大小。在编译时大小未知或大小可能变化的数据，要改为存储在堆上。堆是缺乏组织的：当向堆放入数据时，你要请求一定大小的空间。内存分配器（memory allocator）在堆的某处找到一块足够大的空位，把它标记为已使用，并返回一个表示该位置地址的指针（pointer）。这个过程称作在堆上分配内存（allocating on the heap），有时简称为 “分配”（allocating）。将数据推入栈中并不被认为是分配。因为指针的大小是已知并且固定的，你可以将指针存储在栈上，不过当需要实际数据时，必须访问指针。
入栈比在堆上分配内存要快，因为（入栈时）分配器无需为存储新数据去搜索内存空间；其位置总是在栈顶。相比之下，在堆上分配内存则需要更多的工作，这是因为分配器必须首先找到一块足够存放数据的内存空间，并接着做一些记录为下一次分配做准备。
访问堆上的数据比访问栈上的数据慢，因为必须通过指针来访问。现代处理器在内存中跳转越少就越快（缓存）。
当你的代码调用一个函数时，传递给函数的值（包括可能指向堆上数据的指针）和函数的局部变量被压入栈中。当函数结束时，这些值被移出栈

什么是所有权
跟踪哪部分代码正在使用堆上的哪些数据，最大限度的减少堆上的重复数据的数量，以及清理堆上不再使用的数据确保不会耗尽空间，这些问题正是所有权系统要处理的。
通过所有权系统管理内存，编译器在编译时会根据一系列的规则进行检查。在运行时，所有权系统的任何功能都不会减慢程序。

所有权规则
Rust 中的每一个值都有一个被称为其 所有者（owner）的变量。
值在任一时刻有且只有一个所有者。
当所有者（变量）离开作用域，这个值将被丢弃。
变量作用域
```rust

{ // s 在这里无效, 它尚未声明 let s = “hello”; // 从此处起，s 是有效的，当 s 进入作用域时，它就是有效的 // 使用 s } // 这一直持续到它离开作用域为止。此作用域已结束，s 不再有效

<a name="ezdFH"></a>
### String类型
管理被分配到堆上的数据，该值可变但是字面值不可变。
```rust
let s = String::from("hello");

内存与分配

Rust采用的垃圾回收策略：内存在拥有它的变量离开作用域后就被自动释放。当变量离开作用域，Rust 为我们调用一个特殊的函数。这个函数叫做drop。
就字符串字面值来说，我们在编译时就知道其内容，所以文本被直接硬编码进最终的可执行文件中。这使得字符串字面值快速且高效。不过这些特性都只得益于字符串字面值的不可变性。不幸的是，我们不能为了每一个在编译时大小未知的文本而将一块内存放入二进制文件中，并且它的大小还可能随着程序运行而改变。
对于 String 类型，为了支持一个可变，可增长的文本片段，需要在堆上分配一块在编译时未知大小的内存来存放内容

必须在运行时向内存分配器（memory allocator）请求内存。(String:from)
需要一个当我们处理完 String 时将内存返回给分配器的方法。
变量与数据交互的方式（一）：移动
1、简单值的交互(栈)
```
let x = 5;
let y = x;
现在有了两个变量，x 和 y，都等于 5。
这也正是事实上发生了的，因为整数是有已知固定大小的简单值，所以这两个 5 被放入了栈中。
```
2、所有权(堆)
一个指向存放字符串内容内存的指针，一个长度，和一个容量。长度表示 String 的内容当前使用了多少字节的内存。容量是 String 从分配器总共获取了多少字节的内存。长度与容量的区别是很重要的 ```rust let s1 = String::from(“hello”);

let s2 = s1; //拷贝指针、长度、容量 //在 let s2 = s1 之后，Rust 认为 s1 不再有效，因此 Rust 不需要在 s1 离开作用域后清理任何东西。

![image.png](https://cdn.nlark.com/yuque/0/2021/png/22511976/1639970664939-b2a194ca-9ef6-4d7e-b666-4320ea676c0c.png#clientId=u25f8e3db-0e85-4&from=paste&height=285&id=u477794b9&margin=%5Bobject%20Object%5D&name=image.png&originHeight=570&originWidth=778&originalType=binary&ratio=1&size=33483&status=done&style=none&taskId=u07a03acb-79e1-4de5-98ac-edd59a37d8e&width=389)
<a name="CLnKX"></a>
#### 
<a name="PAf19"></a>
#### 变量与数据交互的方式（一）：克隆
深度复制堆上的数据
```rust
let s1 = String::from("hello");
let s2 = s1.clone();
println!("s1 = {}, s2 = {}", s1, s2);

只在栈上的数据：拷贝

Rust 有一个叫做 Copy trait 的特殊注解，可以用在类似整型这样的存储在栈上的类型上（第十章详细讲解 trait）。如果一个类型实现了 Copy trait，那么一个旧的变量在将其赋值给其他变量后仍然可用。Rust 不允许自身或其任何部分实现了 Drop trait 的类型使用 Copy trait。
任何一组简单标量值的组合都可以实现 Copy，任何不需要分配内存或某种形式资源的类型都可以实现 Copy 。如下是一些 Copy 的类型：

所有整数类型，比如 u32。
布尔类型，bool，它的值是 true 和 false。
所有浮点数类型，比如 f64。
字符类型，char。
元组，当且仅当其包含的类型也都实现 Copy 的时候。比如，(i32, i32) 实现了 Copy，但 (i32, String) 就没有。

所有权与函数
将值传递给函数在语义上与给变量赋值相似。向函数传递值可能会移动或者复制，就像赋值语句一样。 ```rust fn main() { let s = String::from(“hello”); // s 进入作用域

takes_ownership(s); // s 的值移动到函数里 …
```
                              // ... 所以到这里不再有效
```
let x = 5; // x 进入作用域

makes_copy(x); // x 应该移动函数里，
```
                              // 但 i32 是 Copy 的，所以在后面可继续使用 x
```

} // 这里, x 先移出了作用域，然后是 s。但因为 s 的值已被移走， // 所以不会有特殊操作

fn takes_ownership(some_string: String) { // some_string 进入作用域 println!(“{}”, some_string); } // 这里，some_string 移出作用域并调用 drop 方法。占用的内存被释放

fn makes_copy(some_integer: i32) { // some_integer 进入作用域 println!(“{}”, some_integer); } // 这里，some_integer 移出作用域。不会有特殊操作

<a name="QQV58"></a>
### 返回值与作用域
返回值也可以转移所有权
```rust
fn main() {
    let s1 = gives_ownership();         // gives_ownership 将返回值
                                        // 移给 s1
    let s2 = String::from("hello");     // s2 进入作用域
    let s3 = takes_and_gives_back(s2);  // s2 被移动到
                                        // takes_and_gives_back 中,
                                        // 它也将返回值移给 s3
} // 这里, s3 移出作用域并被丢弃。s2 也移出作用域，但已被移走，
  // 所以什么也不会发生。s1 移出作用域并被丢弃
fn gives_ownership() -> String {             // gives_ownership 将返回值移动给
                                             // 调用它的函数
    let some_string = String::from("hello"); // some_string 进入作用域.
    some_string                              // 返回 some_string 并移出给调用的函数
}
// takes_and_gives_back 将传入字符串并返回该值
fn takes_and_gives_back(a_string: String) -> String { // a_string 进入作用域
    a_string  // 返回 a_string 并移出给调用的函数
}

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

引用与借用

&符号就是引用，它们允许你使用值但不获取其所有权。
我们将创建一个引用的行为称为借用（borrowing）
不允许修改引用的值
在任意给定时间，要么只能有一个可变引用，要么只能有多个不可变引用。
引用必须总是有效的。
可变引用
可以修改引用的值，但是在同一时间只能有一个对某一特定数据的可变引用
```
let mut s = String::from("hello");
let r1 = &mut s;
```
可以使用大括号来创建一个新的作用域，以允许拥有多个可变引用 ```rust let mut s = String::from(“hello”);

{ let r1 = &mut s;

} // r1 在这里离开了作用域，所以我们完全可以创建一个新的引用

let r2 = &mut s;

我们也不能在拥有不可变引用的同时拥有可变引用。不可变引用的用户可不希望在他们的眼皮底下值就被意外的改变了！然而，多个不可变引用是可以的。
```rust
let mut s = String::from("hello");
let r1 = &s; // 没问题
let r2 = &s; // 没问题
println!("{} and {}", r1, r2);
// 此位置之后 r1 和 r2 不再使用
let r3 = &mut s; // 没问题
println!("{}", r3);

编译器在作用域结束之前判断不再使用的引用的能力被称为非词法作用域生命周期（Non-Lexical Lifetimes，简称NLL）

悬垂引用

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

fn dangle() -> &String { // dangle 返回一个字符串的引用
    let s = String::from("hello"); // s 是一个新字符串
    &s // 返回字符串 s 的引用
} // 这里 s 离开作用域并被丢弃。其内存被释放。
  // 危险！

fn no_dangle() -> String {
    let s = String::from("hello");
    s //这样就没有任何错误了。所有权被移动出去，所以没有值被释放
}

Slice类型

slice 允许你引用集合中一段连续的元素序列，而不用引用整个集合。

字符串slice

let s = String::from("hello");
let slice = &s[0..2];
let slice = &s[..2];
//编译器会确保指向 String 的引用持续有效
fn first_word(s: &String) -> &str {
    let bytes = s.as_bytes();
    for (i, &item) in bytes.iter().enumerate() {
        if item == b' ' {
            return &s[0..i];
        }
    }
    &s[..]
}

//
当拥有某值的不可变引用时，就不能再获取一个可变引用。
因为 clear 需要清空 String，它尝试获取一个可变引用。
在调用 clear 之后的 println! 使用了 word 中的引用，
所以这个不可变的引用在此时必须仍然有效。
Rust 不允许 clear 中的可变引用和 word 中的不可变引用同时存在，因此编译失败。
fn main() {
    let mut s = String::from("hello world");
    let word = first_word(&s);
    s.clear(); // 错误!
    println!("the first word is: {}", word);
}

字符串字面值就是slice

let s = "Hello, world!";
这里 s 的类型是 &str：它是一个指向二进制程序特定位置的 slice。这也就是为什么字符串字面值是不可变的；&str 是一个不可变引用。

字符串slice值作为参数

其他类型的slice

let a = [1, 2, 3, 4, 5];
let slice = &a[1..3];
assert_eq!(slice, &[2, 3]);

栈和堆

什么是所有权

所有权规则

变量作用域