时间戳

首页 > 解决方案 > 为什么我不能在解构变量后调用方法，但如果我直接访问该字段就可以？

rust - 为什么我不能在解构变量后调用方法，但如果我直接访问该字段就可以？

问题描述

以下未编译：

use std::any::Any;

pub trait CloneBox: Any {
    fn clone_box(&self) -> Box<dyn CloneBox>;
}

impl<T> CloneBox for T
where
    T: Any + Clone,
{
    fn clone_box(&self) -> Box<dyn CloneBox> {
        Box::new(self.clone())
    }
}

struct Foo(Box<dyn CloneBox>);

impl Clone for Foo {
    fn clone(&self) -> Self {
        let Foo(b) = self;
        Foo(b.clone_box())
    }
}

错误信息：

error[E0495]: cannot infer an appropriate lifetime for pattern due to conflicting requirements
  --> src/lib.rs:20:17
   |
20 |         let Foo(b) = self;
   |                 ^
   |
note: first, the lifetime cannot outlive the anonymous lifetime #1 defined on the method body at 19:5...
  --> src/lib.rs:19:5
   |
19 | /     fn clone(&self) -> Self {
20 | |         let Foo(b) = self;
21 | |         Foo(b.clone_box())
22 | |     }
   | |_____^
note: ...so that reference does not outlive borrowed content
  --> src/lib.rs:20:17
   |
20 |         let Foo(b) = self;
   |                 ^
   = note: but, the lifetime must be valid for the static lifetime...
note: ...so that the type `&std::boxed::Box<dyn CloneBox>` will meet its required lifetime bounds
  --> src/lib.rs:21:15
   |
21 |         Foo(b.clone_box())
   |

但是，如果将代码更改为clone()from Foo(b.clone_box())，Foo(self.0.clone_box())则编译没有问题。理论上，字段访问应该和模式匹配一​​样，但是为什么模式匹配会有生命周期的问题呢？

在我的真实代码中，数据位于枚举中，而不是结构中，因此模式匹配是唯一的选择。

标签： rustpattern-matchinglifetime

解决方案

TL;DR：在调用方法之前取消引用值：

Foo((*b).clone_box())

与let Foo(b) = self，类型b为&Box<(dyn CloneBox + 'static)>。方法调用有效

Foo(<&Box<dyn CloneBox + 'static> as CloneBox>::clone_box(&b))

Box<dyn CloneBox + 'static>由于本地引用，该值不能成为特征对象。有趣的是，我相信如果编译器允许，这将递归地使用一揽子实现。

使用self.0.clone_box()，方法调用有效：

Foo(<dyn CloneBox as CloneBox>::clone_box(&**b)

我们可以把它写成Foo((&**b).clone_box())明确的，但由于没有中间实现，Foo((*b).clone_box())就足够了。

也可以看看：

推荐阅读