• 在底层，应用程序内存只是一组字节数组。
• 运行环境通常会将其分段，其中包括：
  • 栈 (stack)（小而低开销的内存，¹ 大多数变量放在这里），
  • 堆 (heap)（大而灵活的内存，但总是通过像 Box<T> 这样的栈代理来处理），
  • 静态区 (static)（最常用作 &str 中 str 部分的存放地），
  • 代码区 (code)（你的函数二进制码所在的地方）。
• 最棘手的部分与栈如何演变有关，这是我们的重点。

let t = S(1);

• 保留一个名为 t 的内存位置，其类型为 S，里面存储的值为 S(1)。
• 如果用 let 声明，该位置存在于栈上。¹
• 注意语言上的模糊性，在术语**变量**中，它可以指：
  1. 源文件中位置的名称（“重命名那个变量”），
  2. 编译后应用中的位置，0x7（“告诉我那个变量的地址”），
  3. 其中包含的值，S(1)（“给那个变量加一”）。
• 特别地，对于编译器，t 可以表示 t 的位置，这里是 0x7，和 t 内的值，这里是 S(1)。

let a = t;

• 这将移动 t 内的值到 a 的位置，如果 S 是 Copy 类型，则会复制它。
• 移动后，位置 t 无效，不能再被读取。
  • 技术上讲，该位置的位并不是真的空的，而是未定义的。
  • 如果你仍然可以（通过 unsafe）访问 t，它们可能仍然看起来像有效的 S，但 任何试图将它们用作有效 S 的尝试都是未定义行为。^↓
• 我们在这里不明确讨论 Copy 类型。它们会稍微改变规则，但不多：
  • 它们不会被 drop。
  • 它们永远不会留下一个“空的”变量位置。

let c: S = M::new();

• 变量的类型有几个重要的作用，它：
  1. 规定了底层位应该如何被解释，
  2. 只允许对这些位进行定义良好的操作，
  3. 防止随机的其他值或位被写入该位置。
• 这里赋值编译失败，因为 M::new() 的字节不能被转换为 S 类型的形式。
• 类型之间的转换通常总是会失败，除非有明确的规则允许（强制转换、类型转换等）。

{
    let mut c = S(2);
    c = S(3);  // <- 在赋值前对 `c` 调用 Drop。
    let t = S(1);
    let a = t;
}   // <- `a`, `t`, `c` 的作用域在此结束，对 `a`, `c` 调用 drop。

• 一旦一个未被移出的变量的“名称”离开其（drop-）作用域，其包含的值将被drop。
  • 经验法则：执行到达变量名称离开其定义的 {} 块的点。
  • 细节上更复杂，尤其是临时值等。
• 当新值赋给现有变量位置时，也会调用 Drop。
• 在这种情况下，Drop::drop() 会在该值的位置上被调用。
  • 在上面的例子中，drop() 在 a 和 c 上被调用了两次，但没有在 t 上调用。
• 大多数非 Copy 的值在大多数时候都会被 drop；例外包括 mem::forget()、Rc 循环、abort()。

fn f(x: S) { … }

let a = S(1); // <- 我们在这里
f(a);

• 当一个函数被调用时，参数（和返回值）的内存会在栈上被保留。¹
• 这里在 f 被调用前，a 中的值被移动到栈上一个“约定好的”位置，在 f 期间，它就像一个“局部变量” x 一样工作。

fn f(x: S) {
    if once() { f(x) } // <- 我们在这里（递归前）
}

let a = S(1);
f(a);

• 递归调用函数，或调用其他函数，同样会扩展栈帧。
• 嵌套太多的调用（尤其通过无界递归）会导致栈增长，并最终溢出，终止应用程序。

fn f(x: S) {
    if once() { f(x) }
    let m = M::new() // <- 我们在这里（递归后）
}

let a = S(1);
f(a);

• 之前持有某种类型的栈内存会在函数调用之间（甚至在函数内部）被复用。
• 这里，对 f 的递归产生了第二个 x，在递归之后，这块内存被部分地用于 m。

到目前为止的关键要点是，有多种方式可以使之前持有某个类型有效值的内存位置在此期间不再持有。 正如我们稍后将看到的，这对指针有影响。

let a = S(1);
let r: &S = &a;

• 一个引用类型，如 &S 或 &mut S，可以持有某个 s 的位置。
• 这里，类型为 &S、绑定为 r 的变量，持有变量 a 的位置（0x3），该位置的类型必须是 S，通过 &a 获得。
• 如果你将变量 c 视为特定位置，那么引用 r 就是一个位置的交换机。
• 引用的类型，像所有其他类型一样，通常可以被推断，所以我们从现在开始可能会省略它：

  let r: &S = &a;
  let r = &a;
  

let mut a = S(1);
let r = &mut a;
let d = r.clone();  // 从 r-目标 克隆是有效的。
*r = S(2);          // 将新的 S 值设置到 r-目标是有效的。

• 引用可以读取（&S）也可以写入（&mut S）它们指向的位置。
• 解引用 *r 意味着使用**r 指向的位置**（不是 r 本身的位置或值）。
• 在这个例子中，克隆 d 是从 *r 创建的，S(2) 被写入到 *r。
  • 我们假设 S 实现了 Clone，并且 r.clone() 克隆的是 r 的目标，而不是 r 本身。
  • 在赋值 *r = … 时，位置中的旧值也会被 drop（上图中未显示）。

let mut a = …;
let r = &mut a;
let d = *r;       // 移出值无效，`a` 会变空。
*r = M::new();    // 存储非 S 值无效，没有意义。

• 虽然绑定保证总是持有有效数据，但引用保证总是指向有效数据。
• 特别是 &mut T 必须提供与变量相同的保证，甚至更多，因为它们不能溶解目标：
  • 它们不允许写入无效数据。
  • 它们不允许移出数据（这会使目标变空而所有者不知道）。

let p: *const S = questionable_origin();

• 与引用相比，指针几乎不提供任何保证。
• 它们可能指向无效或不存在的数据。
• 解引用它们是 unsafe 的，将无效的 *p 当作有效的是未定义行为。^↓

• 程序中的每个实体都有其相关的（时间/空间）范围，即其存活期间。
• 粗略地说，这个存活时间可以是¹
  1. 一个项可用的代码行（LOC）（例如，一个模块名）。
  2. 一个位置被值初始化和该位置被放弃之间的代码行。
  3. 一个位置首次以某种方式被使用和该使用停止之间的代码行。
  4. 一个值被创建和该值被 drop 之间的代码行（或实际时间）。
• 在本节的其余部分，我们将上述各项称为：
  1. 该项的作用域，此处不相关。
  2. 该变量或位置的作用域。
  3. 该使用的生命周期²。
  4. 该值的生命周期，在讨论打开的文件描述符时可能有用，但此处也不相关。
• 同样，代码中的生命周期参数，例如 r: &'a S，
  • 关心的是任何**r 指向的位置**需要被访问或锁定的代码行；
  • 与 r 本身的“存在时间”（作为代码行）无关（当然，它需要存在得更短，就是这样）。
• &'static S 意味着地址必须在所有代码行期间都有效。

¹ 文档中有时在区分各种作用域和生命周期时存在模糊。 我们在这里试图 pragmatic，但欢迎提出建议。

² Live lines 可能是更合适的术语……

• 假设你从某个地方得到了一个 r: &'c S，这意味着：
  • r 持有一个 S 的地址，
  • r 指向的任何地址必须并且将至少存在 'c 这么久，
  • 变量 r 本身的寿命不能长于 'c。

{
    let b = S(3);
    {
        let c = S(2);
        let r: &'c S = &c;      // 不太行，因为我们不能在函数体内命名局部变量的生命周期，
        {                       // 但下一页的函数也适用完全相同的原则。
            let a = S(0);

            r = &a;             // `a` 的位置存活的代码行不够 -> 不行。
            r = &b;             // `b` 的位置存活了 `c` 的所有代码行甚至更多 -> 行。
        }
    }
}

• 假设你从某个地方得到了一个 mut r: &mut 'c S。
  • 也就是说，一个可以持有可变引用的可变位置。
• 如前所述，该引用必须守护目标内存。
• 然而，'c 部分，就像一个类型，也守护着允许进入 r 的东西。
• 这里将 &b（0x6）赋给 r 是有效的，但 &a（0x3）则不行，因为只有 &b 的寿命等于或长于 &c。

let mut b = S(0);
let r = &mut b;

b = S(4);   // 将会失败，因为 `b` 处于借用状态。

print_byte(r);

• 一旦通过 &b 或 &mut b 获取了变量的地址，该变量就被标记为被借用 (borrowed)。
• 在被借用期间，地址的内容不能再通过原始绑定 b 进行修改。
• 一旦通过 &b 或 &mut b 获取的地址停止使用（就代码行而言），原始绑定 b 就可以再次使用了。

fn f(x: &S, y:&S) -> &u8 { … }

let b = S(1);
let c = S(2);

let r = f(&b, &c);

• 当调用接收并返回引用的函数时，会发生两件有趣的事情：
  • 使用的局部变量被置于借用状态，
  • 但在编译时不知道将返回哪个地址。

let b = S(1);
let c = S(2);

let r = f(&b, &c);

let a = b;   // 我可以这样做吗？
let a = c;   // 哪个才是*真正*被借用的？

print_byte(r);

• 由于 f 只能返回一个地址，因此并非在所有情况下 b 和 c 都需要保持锁定。
• 在许多情况下，我们可以获得生活质量的提升。
  • 特别是，当我们知道某个参数不可能再被用于返回值时。

fn f<'b, 'c>(x: &'b S, y: &'c S) -> &'c u8 { … }

let b = S(1);
let c = S(2);

let r = f(&b, &c); // 我们知道返回的引用是基于 `c` 的，它必须保持锁定，
                   // 而 `b` 可以自由移动。

let a = b;

print_byte(r);

• 签名中的生命周期参数，如上面的 'c，解决了这个问题。
• 它们的主要目的是：
  • 在函数外部，解释输出地址是基于哪个输入地址生成的，
  • 在函数内部，保证只有寿命至少为 'c 的地址被赋值。
• 实际的生命周期 'b、'c 由编译器在调用点根据开发者提供的被借用变量透明地选择。
• 它们不等于 b 或 c 的作用域（即从初始化到销毁的代码行），而只是其作用域的一个最小子集，称为生命周期，即基于 b 和 c 需要被借用多长时间来执行此调用并使用获得的结果的最小代码行集。
• 在某些情况下，比如如果 f 有 'c: 'b，我们仍然无法区分，两者都需要保持锁定。

let mut c = S(2);

let r = f(&c);
let s = r;
                    // <- 不是这里，`s` 延长了 `c` 的锁定。

print_byte(s);

let a = c;          // <- 但是在这里，不再使用 `r` 或 `s`。

• 一旦任何可能指向它的引用的最后一次使用结束，变量位置就会再次被解锁。

// 返回短 ('b) 引用
fn f1sr<'b, 'a>(rb: &'b     &'a     S) -> &'b     S { *rb }
fn f2sr<'b, 'a>(rb: &'b     &'a mut S) -> &'b     S { *rb }
fn f3sr<'b, 'a>(rb: &'b mut &'a     S) -> &'b     S { *rb }
fn f4sr<'b, 'a>(rb: &'b mut &'a mut S) -> &'b     S { *rb }

// 返回短 ('b) 可变引用。
// f1sm<'b, 'a>(rb: &'b     &'a     S) -> &'b mut S { *rb } // M
// f2sm<'b, 'a>(rb: &'b     &'a mut S) -> &'b mut S { *rb } // M
// f3sm<'b, 'a>(rb: &'b mut &'a     S) -> &'b mut S { *rb } // M
fn f4sm<'b, 'a>(rb: &'b mut &'a mut S) -> &'b mut S { *rb }

// 返回长 ('a) 引用。
fn f1lr<'b, 'a>(rb: &'b     &'a     S) -> &'a     S { *rb }
// f2lr<'b, 'a>(rb: &'b     &'a mut S) -> &'a     S { *rb } // L
fn f3lr<'b, 'a>(rb: &'b mut &'a     S) -> &'a     S { *rb }
// f4lr<'b, 'a>(rb: &'b mut &'a mut S) -> &'a     S { *rb } // L

// 返回长 ('a) 可变引用。
// f1lm<'b, 'a>(rb: &'b     &'a     S) -> &'a mut S { *rb } // M
// f2lm<'b, 'a>(rb: &'b     &'a mut S) -> &'a mut S { *rb } // M
// f3lm<'b, 'a>(rb: &'b mut &'a     S) -> &'a mut S { *rb } // M
// f4lm<'b, 'a>(rb: &'b mut &'a mut S) -> &'a mut S { *rb } // L

// 现在假设我们有一个 `ra`
let mut ra: &'a mut S = …;

let rval = f1sr(&&*ra);       // OK
let rval = f2sr(&&mut *ra);
let rval = f3sr(&mut &*ra);
let rval = f4sr(&mut ra);

//  rval = f1sm(&&*ra);       // 会很糟，因为 rval 将是从
//  rval = f2sm(&&mut *ra);   // 破碎的可变性链中获得的可变引用。
//  rval = f3sm(&mut &*ra);   //
let rval = f4sm(&mut ra);

let rval = f1lr(&&*ra);
//  rval = f2lr(&&mut *ra);   // 如果这行得通，我们现在就有 `rval` 和 `ra`……
let rval = f3lr(&mut &*ra);
//  rval = f4lr(&mut ra);     // ……（可变地）别名了下面的计算中的 `S`。

//  rval = f1lm(&&*ra);       // 与上面相同，因可变链原因失败。
//  rval = f2lm(&&mut *ra);   //                    "
//  rval = f3lm(&mut &*ra);   //                    "
//  rval = f4lm(&mut ra);     // 与上面相同，因别名原因失败。

// 某个我们使用 `ra` 和 `rval` 的虚构地方，两者都存活。
compute(ra, rval);

• f_sr 情况总是有效，短引用（只活 'b）总是可以产生。
• f_sm 情况通常失败，因为需要一个可变链到 S 才能返回 &mut S。
• f_lr 情况可能失败，因为从 &'a mut S 返回 &'a S 给调用者意味着现在将存在两个对同一 S 的引用（一个可变），这是非法的。
• f_lm 情况总是因上述原因的组合而失败。

注意：这个例子是关于 f 函数，而不是 compute。你可以假设 它被定义为 fn compute(x: &S, y: &S) {}。在这种情况下，ra 参数 将被自动强制转换^↓从 &mut S 到 &S，因为你不能有 一个共享引用和一个可变引用指向同一个目标。

{
    let f = |x, y| (S(x), S(y)); // 返回两个'可 Drop' 的函数。

    let (    x1, y) = f(1, 4);  // S(1) - 作用域   S(4) - 作用域
    let (    x2, _) = f(2, 5);  // S(2) - 作用域   S(5) - 立即
    let (ref x3, _) = f(3, 6);  // S(3) - 作用域   S(6) - 作用域

    println!("…");
}

• 产生可移动值的函数或表达式必须由被调用方处理。
• 存储在“正常”绑定中的值会保留到作用域结束，然后被 drop。
• 存储在 _ 绑定中的值通常会立即被 drop。
• 然而，有时引用（例如 ref x3）可以使值（例如元组 (S(3), S(6))）保留更长时间，因此作为该元组一部分的 S(6) 只能在对其兄弟 S(3) 的引用消失后才能被 drop。