• 应用程序内存在底层就是一个字节数组.
• 操作系统经常将其划分为若干分区:
  • 栈区 (空间小, 低成本内存,¹ 多数 变量 都在这里),
  • 堆区 (空间大, 可扩展内存, 但总会由类似 Box<T> 的栈代理来指向),
  • 静态区 (多用于存储组成 &str 的字符串 str),
  • 代码区 (你的函数二进制代码的存储区域).
• 这里面最富挑战的莫过于栈的增长, 这是我们关注的重点.

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 的操作都是未定义行为 (UB). ^↓
• 这里没有提到 Copy 的影响, 虽然它会轻微影响上述规则:
  • 它们不会被析构.
  • '空'变量的位置永远不会离开作用域.

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

• 变量的类型指出了许多重要的期望, 它:
  1. 规定了如何解释底层的比特位,
  2. 仅允许被友好定义的操作去操作这些比特位,
  3. 防止其他随机变量或比特写到这个位置.
• 这里赋值语句将会编译失败, 因为 M::new() 的字节无法被有效地转换为 S 类型.
• 类型之间的直接转换 总会 失败. 但通常允许某些例外 (强转或 as 转换等).

{
    let mut c = S(2);
    c = S(3);  // <- 赋值前将会对 `c` 进行析构.
    let t = S(1);
    let a = t;
}   // <- 这里退出了 `a`, `t`, `c` 的作用域, 将调用 `a`, `c` 的析构方法.

• 一旦一个未腾出空间的“变量名”离开其作用域, 其包含的值将被析构.
  • 首要规则: 当变量名离开其定义的 {} 块时执行,
  • 临时变量等尤为如此.
• 当新值赋值给已有变量位置时也会触发析构.
• 当调用了值对应位置的 Drop::drop() 时.
  • 上例中 drop() 在 a 上调用了一次, 在 c 上调用了两次, 但没有在 t 上调用过.
• 多数非 Copy 的值都在此时发生析构, 除非使用了 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);          // 将 r 指向目标设置为新值 S.

• 引用可以读取自 (&S) 或写入到 (&mut S) 它们指向的位置.
• 解引用 *r 表示既不使用 r 的 位置 也不使用其包含的 值, 而是使用位置 r 指向的目标.
• 上例中, 克隆 d 是由 *r 创建的, 并且 S(2) 写入到了 *r.
  • 方法 Clone::clone(&T) 期望传入其自身的引用, 这就是我们使用 r 而非 *r 的原因.
  • 赋值语句 *r = ... 中的旧值也会被析构 (图中未说明).

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 作为有效值来操作是未定义行为 (UB). ^↓

• 程序中的每个实体都有其相关的临时或者长期的空间, 即 生存.
• 宽松地说, 生存时间 可以是¹
  1. 项目可用的代码行 (LOC). (如模块名).
  2. 从 位置 的初始化到位置被丢弃之间的代码行.
  3. 从位置第一次确定性使用到停止使用之间的代码行.
  4. 从创建 值 到该值被析构之间的代码行 (或实际时间).
• 本节剩余部分会将上面的项目分别称为:
  1. 项目作用域, 不重要.
  2. 变量或位置的作用域.
  3. 用法的生命周期².
  4. 值的生命周期, 当和文件描述符打交道时非常有用, 但这里也不重要.
• 同样地, 代码中的生命周期参数 r: &'a S
  • 任意位置 r 指向 的代码行导致的未确定态都要求可访问或被锁定;
  • 与 r 本身作为代码行的“存在时间”并无关联 (它只要存在得更短就行了).
• &'static S 意味着地址必须 在所有代码行中有效.

¹ 文档中的 作用域 和 生命周期 有时存在歧义. 这里尝试作一定的区分, 但如果有更好的意见也欢迎提出.

² 生存行 可能是个更好的说法...

• 假设你从哪里看到 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 捕获, 变量就会被标记为已借用.
• 借用时, 就不能再通过原始绑定 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`.

• 一旦任意引用最后指向了结束, 变量位置将会再次 解锁.