Rust 可变引用的重传

当我想知道如何将可变引用转化为方法时，所有的问题都开始了

let a = &mut x;
a.somemethod(); // value of a should have moved
a.anothermethod(); // but it works.

我在谷歌上搜索了很多。（真的很多） 我注意到，作为参数传递给函数的可变引用总是经历以下转换。（称为重新箭头）

所以，我在谷歌上搜索了更多关于“重传”的细节

这就是我得到的

在任何代码中，x表示任意数据。我不提它，因为我认为它的类型对讨论不重要。（不过，我自己也使用了i32）

好吧。这很有趣。似乎

b

不仅借用了

x

，而且还借用了

a

也许，我们可以像这样澄清重新加载：

&'a*（&'b mut x）

。 它借用了

x

（在这里有一个生命周期'a）， 但也借用了

a

（它的生命周期为'b'）

所以我运行下面的代码来证实我的猜测

let x: i32 = 1; // I wanted to make it clear that x lives in this scope.
let b;
{
    let a = &mut x;
    b = &mut *a;
}
*b = 0;

但这是有效的

什么？？ 但我只是决定买这个。

&'a mut*&mutx

，而不是

&'a mut*&b mutx

我不知道为什么

mut x

在

&mut*&mutx

的生命周期内不可用，也不知道

mut x

在

&mut*&mutx

的生命周期后为什么会重新可用，但是“好吧，我们就这么说吧”

但是看看这个。我完全不想有一个清晰而全面的理解

let x: i32 = 1;
let b;
{
    let a = &mut x;
    let b = &**&a;
} // error!! a should live longer than b!

生命周期不是仅仅依赖于真实数据所指的吗？？？

&'a**&&mut x

，而不是

&'a**&'b&'c mut x

现在呢

&'a**&'b&mut x

？？？（这是我的猜测）

---

我该如何接受这种复杂的局面呢？

这些都是很好的问题！我会尽力回答我能回答的问题

Rust参考是一个很好的地方，可以找到类似这样的问题的答案，关于Rust更深层次的语义

首先，关于方法解析的问题：

查找方法调用时，接收器可能会自动 为了调用方法而取消引用或借用。这需要一个 查找过程比其他函数更复杂，因为可能存在 可以调用许多可能的方法。下面的程序是 使用：

第一步是建立候选接收器类型的列表。获得 通过反复取消对接收器的引用，可以实现这些功能 表达式的类型，将遇到的每个类型添加到列表中，然后 最后尝试在末尾执行非大小强制，并添加 如果成功，则返回结果类型。然后，对于每个候选

T

，添加

&T

和

&mut T T

紧跟在

T

之后

例如，如果接收器具有类型

框

，则 候选类型将是

Box

，

&Box

，

&mut-Box

，

[i32；2]

（通过取消引用），

&[i32；2]

，

&mut[i32；2]

，

[i32]

，

和[i32]

，最后是

&mut[i32]

上面的链接更详细

关于你剩下的问题，我认为这主要是关于类型强制的

• &mut T T

  到

  &T

• &T

  或

  &mut T T

  到

  &U

  如果

  T

  实现

  Deref

• &mut T T

  到

  &mut U

  如果

  T

  执行

  DerefMut

值得注意的是，

&U

和

&mut-U

都实现了

Deref

，而

&mut-U

也实现了

DerefMut

。因此，第二条/第三条规则导致以下强制：

设

T

为： 胁迫 到

&U

和&U

&U

&U

&mut&U

&U

&mut U

和&mut U

&U

&mut U

&mut&mut U

&mut U

---

我对生命的表达完全是胡说八道。对不起，我的问题不好。忽略它吧。正因为如此，它在综合和理解大量信息以使其清晰化方面非常有帮助。在写这篇文章的时候，我的头脑非常混乱，以至于问题没有组织起来。非常感谢你！我很高兴能帮上忙！如果答案回答了您的所有问题，请务必将其标记为已接受。

let a = &mut x;
{
    let b = &*a;
    // *a = blahblah in this scope will throw an error, just like above case.
}
*a = blahblah; // but this works.

let x: i32 = 1; // I wanted to make it clear that x lives in this scope.
let b;
{
    let a = &mut x;
    b = &mut *a;
}
*b = 0;

let x: i32 = 1;
let b;
{
    let a = &mut x;
    let b = &**&a;
} // error!! a should live longer than b!