[TOC]
Rust中的作用域及作用域的规则
所有权是 Rust 最独特的特性，它使 Rust 能够在不需要 GC 的情况下保证内存安全。在本章中，我们将讨论所有权以及几个相关特性：借用/切片，以及 Rust 如何在内存中布局数据。
Rust中的所有权
Rust 的内存管理模型
所有权是 Rust 这门编程语言的核心概念，Rust 最引以为豪的内存安全就建立在所有权之上。
所有的编程语言都存在某种管理内存的机制，拿 C 语言来说，这种机制是 malloc 和 free。这意味着开发者要手动管理内存。对于编程高手而言，这是一种拥有无限可能性的技术，但对于大多数普通人而言，它是一个 Bug 制造机器。一些语言采用了垃圾回收技术来管理内存，也就是说开发者可以只申请内存而不用手动去释放内存，然后，垃圾回收器，也就是 GC，会自动检测某块内存是否已经不再被使用，如果是的话，那么释放这块内存。但是因为 GC 的存在导致程序性能天生的下降，还有就是 GC 对程序运行带来的不确定性，任何使用 GC 的语言几乎不可能用来编写底层程序。我们这里说的底层是指贴近硬件的软件应用，例如操作系统和硬件驱动。
在生活中，如果有两种合理但不同的方法时，你应该总是研究两者的结合，看看能否找到两全其美的方法。我们称这种组合为杂合（hybrid）。例如，为什么只吃巧克力或简单的坚果，而不是将两者结合起来，成为一块可爱的坚果巧克力呢？
Rust 采用了一种中间方案 RAII（Resource Acquisition Is Initialization），它兼具 GC 的易用性和安全性，同时又有极高的性能。
栈和堆
在开始之前，我们先来回顾一下堆和栈的区别。栈是一种先进先出的数据结构，栈内的每个元素都有固定的大小，通常是你机器 CPU 的位宽。例如，如果你现在在使用 64 位机器，那么你机器上运行的任何程序的栈的宽度就是 64 位，正好是一个寄存器的大小。另一方面，如果我们要放置某个对象，例如一个字符串，由于字符串的长度是不固定的，因此无法被放置在栈中。此时我们必须使用堆，而当我们想要在堆上分配一个对象，我们向操作系统请求给定的内存数量，操作系统会在可用堆中找到一个空闲位置，然后讲标记设置为已占用，并返回指向该存储位置的指针，因此堆的组织性较差，它比栈要慢，但很多时候它是唯一的处理这些动态结构的方法。下图展示了一个字符是如何存储在内存中的：变量 s 保存在栈中，其值是一个指向堆的地址，堆中则保存了字符串的具体内容。
所有权的实际规则
- Rust 中每个值都绑定有一个变量，称为该值的所有者。
- 每个值只有一个所有者，而且每个值都有它的作用域。
- 一旦当这个值离开作用域，这个值占用的内存将被回收。
fn main() {
let value1 = 1;
println!("{}", value1);
{
let value2 = 2;
}
// 无法在value2的作用域之外使用该变量
// println!("{}", value2);
let s1 = String::from("hello world");
// 发生了所有权的转移
let s2 = s1;
// 由于每个值只有一个所有者，所以当所有权转移后，就无法访问s1了
// println!("{}", s1);
// 而所有权转移到了s2上，所以s2能够正常访问
println!("{}", s2);
let s3: String;
{
let s4 = String::from("hello world");
s3 = s4;
// 所有权转移了所以无法访问
// println!("{}", s4);
}
// 所有权转移给了s3，此时该值的作用域也变成了s3的作用域，所以离开了s4的作用域该值还能访问
println!("{}", s3);
}
Rust中的借用
在有些时候，我们希望使用一个值而不拥有这个值。这种需求在函数调用时特别常见，思考以下代码：
fn echo(s: String) {
println!("{}", s);
}
fn main() {
let s = String::from("Hello World!");
echo(s);
println!("{}", s);
}
编译将得到一个错误，我们不能再使用变量 s，应为 s 的值已经被转移到函数 echo 了。
error[E0382]: borrow of moved value: `s`
--> src/main.rs:8:20
|
6 | let s = String::from("Hello World!");
| - move occurs because `s` has type `String`, which does not implement the `Copy` trait
7 | echo(s);
| - value moved here
8 | println!("{}", s);
| ^ value borrowed here after move
函数 echo 并不想要拥有 “Hello World!”，它只是想去临时使用以下它。这类功能通过使用引用来提供。通过引用，我们可以“借用”一些值，而无需拥有它们。这与Golang中实现引用传递的做法是类似的，就是传个指针类型而不是值。
fn echo(s: &String) {
println!("{}", s);
}
fn main() {
let s = String::from("Hello World!");
echo(&s);
println!("{}", s);
}
不可变引用与可变引用
默认情况下，引用是不可变的。如果希望修改引用的值，需要使用 &mut，如下代码所示：
fn change(s: &mut String) {
s.push_str(" changed!")
}
fn main() {
let mut s = String::from("Hello World!");
change(&mut s);
println!("{}", s);
}
可变引用的规则
可变引用具有一个最重要的规则：同一时间至多只能存在一个可变引用。此规则主要用于防止数据竞争，这样不同的线程之间就无法修改同一块内存了：
fn main() {
let s = String::from("Hello World!");
let s1_ref = &mut s;
let s2_ref = &mut s; // cannot borrow as mutable
}
生命周期
一个变量的生命周期从创建的时候开始，到销毁该变量的时候生命周期结束。编译器通过生命周期确保所有的借用都是有效的：即确保借用存在时，原值不会被销毁。在绝大多数情况下，生命周期和变量的作用域是一致的：
fn main() {
let i = 3; // i 的生命周期开始
{
let borrow1 = &i; // borrow1 的生命周期开始
println!("borrow1: {}", borrow1);
} // borrow1 的生命周期结束
{
let borrow2 = &i; // borrow2 的生命周期开始
println!("borrow2: {}", borrow2);
} // borrow2 的生命周期结束
} // i 的生命周期结束
在上述的代码中，可以看到对一个值的引用的生命周期总是处于原值的生命周期之内。
生命周期注解
在绝大多数情况下，Rust 编译器可以自动推导每个变量的生命周期。但有时候也需要我们手动在代码中注明生命周期，例如存在两个不同的引用变量，而编译器又无法自动推导的情况。比较常见的场景是与 &str 交互的时候。生命周期注解有着一个不太常见的语法：生命周期参数名称必须以撇号 ' 开头，其名称通常全是小写，类似于泛型其名称非常短。 'a 是大多数人默认使用的名称。生命周期参数注解位于引用的 & 之后，并有一个空格来将引用类型与生命周期注解分隔开。
例 1：接受两个字符串并返回字典序较大的字符串的函数：
fn bigger<'a>(str1: &'a str, str2: &'a str) -> &'a str {
if str1 > str2 {
str1
} else {
str2
}
}
fn main() {
println!("{}", bigger("a", "b"));
}
要注意的是，生命周期注解并不改变任何引用的生命周期的长短。
例 2：定义存在一个 &str 类型字段的结构体。
struct Person<'a> {
name: &'a str,
}
fn main() {
let p = Person {name: "Jack"};
println!("{}", p.name);
}
静态生命周期
具有静态生命周期的引用在整个程序运行期间一直存在。它使用 static 关键字。具有静态生命周期的对象容易与常量搞混淆，虽然两者都在整个程序运行之中存在，但它们的区别是静态生命周期的对象有且只有一个内存地址，而常量则不一定。
我们以下面这个例子来理解静态生命周期。我们试图编写一个函数，该函数返回一个字符串 &str。但问题来了，字符串的内容 “Hello World!” 的作用域是函数体，而函数却试图返回它的引用。为了解决这个问题，需要将 &str 修改为 &'static str，它表明其所引用的内容的生命周期是整个程序运行期间。
fn hello_world() -> &'static str {
return "Hello World!";
}
何时应该使用静态生命周期：
- 正在存储大量数据
- 静态对象的单地址属性是必需的
- 内部可变性是必需的（静态对象是允许可变的）
static mut LEVELS: u32 = 0;
fn main() {
// 因为 static mut 允许多线程进行修改
// 所以对 static mut 的修改必须放置在 unsafe 块中
unsafe {
println!("{}", LEVELS);
LEVELS += 1;
println!("{}", LEVELS);
}
}
