RUST 引用

let x = 5;

let y = &5;

let z= &x;

x 是 i32 整型，y,z 是引用类型，用&是取引用符

新加变量 x,并绑定 5 数据，

新增加变量 y，并绑定 5 数据的引用地址

新增变量 z, 并绑定 x 的引用地址

上面每个变量在内存中都是不同的存储

第一行，在栈中添加变量，而且变量的值是 5，都在栈中

第二行，在栈中增加一个数据 5，再再栈中创建一个变量 y，并把 5 所在的内存地址，给 y;

第三行 在栈中增加一个变量，把 x 所在的内存地址赋值给 z

每行都是在内存新开辟一块空间，存变量，而且变量的值都是不同的，y 和 z 的内存地址并不相同

let x = 5;

let h = &x;

let k = &x;

上面 h,k 拥有相同的值，x 的内存地址确定，h,k 都是取 x 的内存地址，所有 h 和 k 是同等的，根据之前的说明，那如果

let g = &5;是不是就说明 h==k 是 true, h==g 是 false,k==g 也是 false

其实不然，虽然 g=&5; g 的值和 h,k 都不相同，但是在调用==的时候，会产生自动解码的操作，会直接比较指针的值所以，h==g 和 k==g 都是 true

有点需要特别说明，指针的指针这种情况，看下面例子,先不提有没有必要，编译器是支持的

let x = 5;

let y = &&x;

let z = &&x;

y 和 z 的内存地址是不相同的，具体的原理不是很明白，就根据我的理解（我让我信服的理由）&x 取 x 的引用保存到一块空间，&&x 然后再取这个空间的地址，因为我们并没有把&x;存这块空间绑定到一个变量上，所以每次取&x,都会产生一个新的空间，所以每次取这个地址都是一个新的内存地址

最后说下解引用，就是用*号来解引用，使用引用指向的数据，如果没有解引用，那就是

let x = 5;

let y = &5;

let z = x+*y;

上面代码没有错，正常编译执行，y 的类型是个 引用类型，*号把 y 解引用就是 5，相加正常，

如果 z 换成 let z = x+y;呢，也是正常执行和编译的，这是因为编译器自动把 y 解引用了，

impl<'a, 'b> Add<&'a i32> for &'b i32

fn add(self, other: &'a i32) -> >::Output

类似于如何使用 Deref trait 重载不可变引用的 * 运算符，Rust 提供了 DerefMut trait 用于重载可变引用的 * 运算符。

Rust 在发现类型和 trait 实现满足三种情况时会进行解引用强制多态：

当 T: Deref 时从 &T 到 &U。

当 T: DerefMut 时从 &mut T 到 &mut U。

当 T: Deref 时从 &mut T 到 &U。

头两个情况除了可变性之外是相同的：第一种情况表明如果有一个 &T，而 T 实现了返回 U 类型的 Deref，则可以直接得到 &U。第二种情况表明对于可变引用也有着相同的行为。

最后一个情况有些微妙：Rust 也会将可变引用强转为不可变引用。但是反之是 不可能 的：不可变引用永远也不能强转为可变引用。因为根据借用规则，如果有一个可变引用，其必须是这些数据的唯一引用（否则程序将无法编译）。将一个可变引用转换为不可变引用永远也不会打破借用规则。将不可变引用转换为可变引用则需要数据只能有一个不可变引用，而借用规则无法保证这一点。因此，Rust 无法假设将不可变引用转换为可变引用是可能的