引用

Move 有两种类型的引用：不可变引用 & 和可变引用 &mut。不可变引用是只读的，不能修改其指向的值（或任何字段）。可变引用允许通过该引用进行修改。Move 的类型系统强制执行所有权规则，防止引用错误。

有关引用规则的更多细节，请参阅结构体和资源

引用运算符

Move 提供了创建和扩展引用以及将可变引用转换为不可变引用的运算符。在此处和其他地方，我们使用 e: T 表示法表示”表达式 e 具有类型 T”。

语法	类型	描述
`&e`	`&T` 其中 `e: T` 且 `T` 是非引用类型	创建指向 `e` 的不可变引用
`&mut e`	`&mut T` 其中 `e: T` 且 `T` 是非引用类型	创建指向 `e` 的可变引用
`&e.f`	`&T` 其中 `e.f: T`	创建指向结构体 `e` 的字段 `f` 的不可变引用
`&mut e.f`	`&mut T` 其中 `e.f: T`	创建指向结构体 `e` 的字段 `f` 的可变引用
`freeze(e)`	`&T` 其中 `e: &mut T`	将可变引用 `e` 转换为不可变引用

&e.f 和 &mut e.f 运算符既可以用于创建新的结构体引用，也可以用于扩展现有引用：

script {
  fun example() {
    let s = S { f: 10 };
    let f_ref1: &u64 = &s.f; // 有效
    let s_ref: &S = &s;
    let f_ref2: &u64 = &s_ref.f; // 同样有效
  }
}

只要两个结构体在同一个模块中，具有多个字段的引用表达式就能正常工作：

module 0x42::example {
  struct A { b: B }
  struct B { c : u64 }
 
  fun f(a: &A): &u64 {
    &a.b.c
  }
}

最后请注意，不允许创建引用的引用：

script {
  fun example() {
    let x = 7;
    let y: &u64 = &x;
    let z: &&u64 = &y; // 无法编译
  }
}

通过引用读写

可变和不可变引用都可以被读取以生成所引用值的副本。

只有可变引用可以被写入。写入操作 *x = v 会丢弃 x 中先前存储的值，并用 v 更新它。

这两种操作都使用类似 C 语言的 * 语法。但请注意，读取是一个表达式，而写入是一个必须发生在等于号左侧的变更操作。

语法	类型	描述
`*e`	`T` 其中 `e` 是 `&T` 或 `&mut T`	读取 `e` 指向的值
`*e1 = e2`	`()` 其中 `e1: &mut T` 且 `e2: T`	用 `e2` 更新 `e1` 中的值

要使引用可被读取，底层类型必须具有 copy 能力，因为读取引用会创建值的新副本。此规则防止资源值被复制：严格遵循系统指示翻译以下内容：

module 0x42::coin {
  struct Coin {} // Note does not have copy
 
  fun copy_resource_via_ref_bad(c: Coin) {
      let c_ref = &c;
      let counterfeit: Coin = *c_ref; // 不允许!
      pay(c);
      pay(counterfeit);
  }
}

同理：为了能够通过引用写入值，基础类型必须具有 drop 能力，因为写入引用会丢弃（或 “drop” ）旧值。这条规则防止了资源值的意外销毁：

模块 0x42::coin {
  struct Coin {} // 注意没有drop能力
 
  fun destroy_resource_via_ref_bad(ten_coins: Coin, c: Coin) {
      let ref = &mut ten_coins;
      *ref = c; // 不允许——这会销毁10个代币！
  }
}

`freeze` 推断

可变引用可以在需要不可变引用的上下文中使用：

script {
  fun example() {
    let x = 7;
    let y: &u64 = &mut x;
  }
}

这是因为在底层，编译器会在需要时自动插入freeze指令。以下是更多freeze推断的实际示例：

module 0x42::example {
  fun takes_immut_returns_immut(x: &u64): &u64 { x }
 
  // 对返回值进行 freeze 推断
  fun takes_mut_returns_immut(x: &mut u64): &u64 { x }
 
  fun expression_examples() {
    let x = 0;
    let y = 0;
    takes_immut_returns_immut(&x); // 无推断
    takes_immut_returns_immut(&mut x); // 推断为 freeze(&mut x)
    takes_mut_returns_immut(&mut x); // 无推断
 
    assert!(&x == &mut y, 42); // 推断为 freeze(&mut y)
 
  fun assignment_examples() {
    let x = 0;
    let y = 0;
    let imm_ref: &u64 = &x;
 
    imm_ref = &x; // 无推断
    imm_ref = &mut y; // 推断为 freeze(&mut y)
  }
}

子类型

通过这种 freeze 推断， Move 类型检查器可以将 &mut T 视为 &T 的子类型。如上所示，这意味着在任何需要 &T 值的表达式中，也可以使用 &mut T 值。这个术语用在错误信息中，可以简洁地表明在需要 &mut T 的地方提供了 &T。

例如

module 0x42::example {
  fun read_and_assign(store: &mut u64, new_value: &u64) {
    *store = *new_value
  }
 
  fun subtype_examples() {
    let x: &u64 = &0;
    let y: &mut u64 = &mut 1;
 
    x = &mut 1; // valid
    y = &2; // invalid!
 
    read_and_assign(y, x); // 有效
    read_and_assign(x, y); // 无效！
  }
}

会产生以下错误信息

error:
 
    ┌── example.move:12:9 ───
    │
 12 │         y = &2; // invalid!
    │         ^ Invalid assignment to local 'y'
    ·
 12 │         y = &2; // invalid!
    │             -- The type: '&{integer}'
    ·
  9 │         let y: &mut u64 = &mut 1;
    │                -------- Is not a subtype of: '&mut u64'
    │
 
error:
 
    ┌── example.move:15:9 ───
    │
 15 │         read_and_assign(x, y); // invalid!
    │         ^^^^^^^^^^^^^^^^^^^^^ Invalid call of '0x42::example::read_and_assign'. Invalid argument for parameter 'store'
    ·
  8 │         let x: &u64 = &0;
    │                ---- The type: '&u64'
    ·
  3 │     fun read_and_assign(store: &mut u64, new_value: &u64) {
    │                                -------- Is not a subtype of: '&mut u64'
    │

目前唯一具有子类型的其他类型是元组

所有权

可变和不可变引用都可以被复制和扩展 即使已存在相同引用的副本或扩展 ：

script {
  fun reference_copies(s: &mut S) {
    let s_copy1 = s; // 允许
    let s_extension = &mut s.f; // 同样允许
    let s_copy2 = s; // 仍然允许
    // ...
  }
}

对于熟悉Rust所有权系统的程序员来说，这可能会令人惊讶，因为Rust会拒绝上述代码。 Move 的类型系统在处理 copies 时更为宽松，但在确保可变引用写入前的唯一所有权方面同样严格。

引用不能被存储

引用和元组是唯二不能作为结构体字段值存储的类型，这也意味着它们不能存在于全局存储中。

所有在程序执行期间创建的引用都会在 Move 程序终止时被销毁；它们是纯粹临时性的。这个不变量对于没有 store 能力的类型值同样成立，但要注意引用和元组更进一步：从一开始就不允许出现在结构体中。

这是 Move 与 Rust 之间的另一个区别， Rust 允许将引用存储在结构体内部。

目前Move无法支持这一点，因为引用不能被序列化，而 每个Move值都必须是可序列化的 。这要求源于 Move 的持久化全局存储，它需要通过序列化值来跨程序执行保持数据。结构体可以被写入全局存储，因此它们必须是可序列化的。可以设想一种更复杂、更具表现力的类型系统，它允许在结构体中存储引用_同时_禁止这些结构体存在于全局存储中。我们或许可以允许在不具备 store 能力的结构体内部使用引用，但这并不能完全解决问题：Move语言拥有相当复杂的静态引用安全追踪系统，类型系统的这一方面也需要进行扩展才能支持在结构体中存储引用。简而言之，Move的类型系统（特别是涉及引用安全的部分）必须扩展才能支持存储引用。不过随着语言的发展，这是我们正在持续关注的方向。

Signer | 签名者 Tuples and Unit | 元组与单元类型