指针和引用

对指针来说，解构（destructure）和解引用（dereference）要区分开，因为这两者的概念是不同的，和 C 那样的语言用法不一样。

  • 解引用使用 *
  • 解构使用 &、ref、和 ref mut
  1. fn main() {
  2.     // 获得一个 `i32` 类型的引用。`&` 表示取引用。
  3.     let reference = &4;
  5.     match reference {
  6.         // 如果用 `&val` 这个模式去匹配 `reference`，就相当于做这样的比较：
  7.         // `&i32`（译注：即 `reference` 的类型）
  8.         // `&val`（译注：即用于匹配的模式）
  9.         // ^ 我们看到，如果去掉匹配的 `&`，`i32` 应当赋给 `val`。
  10.         // 译注：因此可用 `val` 表示被 `reference` 引用的值 4。
  11.         &val => println!("Got a value via destructuring: {:?}", val),
  12.     }
  14.     // 如果不想用 `&`，需要在匹配前解引用。
  15.     match *reference {
  16.         val => println!("Got a value via dereferencing: {:?}", val),
  17.     }
  19.     // 如果一开始就不用引用，会怎样？ `reference` 是一个 `&` 类型，因为赋值语句
  20.     // 的右边已经是一个引用。但下面这个不是引用，因为右边不是。
  21.     let _not_a_reference = 3;
  23.     // Rust 对这种情况提供了 `ref`。它更改了赋值行为，从而可以对具体值创建引用。
  24.     // 下面这行将得到一个引用。
  25.     let ref _is_a_reference = 3;
  27.     // 相应地，定义两个非引用的变量，通过 `ref` 和 `ref mut` 仍可取得其引用。
  28.     let value = 5;
  29.     let mut mut_value = 6;
  31.     // 使用 `ref` 关键字来创建引用。
  32.     // 译注：下面的 r 是 `&i32` 类型，它像 `i32` 一样可以直接打印，因此用法上
  33.     // 似乎看不出什么区别。但读者可以把 `println!` 中的 `r` 改成 `*r`，仍然能
  34.     // 正常运行。前面例子中的 `println!` 里就不能是 `*val`，因为不能对整数解
  35.     // 引用。
  36.     match value {
  37.         ref r => println!("Got a reference to a value: {:?}", r),
  38.     }
  40.     // 类似地使用 `ref mut`。
  41.     match mut_value {
  42.         ref mut m => {
  43.             // 已经获得了 `mut_value` 的引用，先要解引用，才能改变它的值。
  44.             *m += 10;
  45.             println!("We added 10. `mut_value`: {:?}", m);
  46.         },
  47.     }
  48. }

参见：

ref 模式