Question

由于使用了相关类型，因为使用了相关类型，我得到了一个生命周期错误，由以下两个类似的程序演示，第一个编译没有错误，第二个编译有生命周期错误。

计划＃1 - 无错误编译

trait Trait<'a> {
    type T;
}

struct Impl;

impl<'a> Trait<'a> for Impl {
    type T = std::marker::PhantomData<&'a ()>;
}

struct Alpha<'a, T: Trait<'a>> {
    _dummy: std::marker::PhantomData<(&'a (), T)>,
}

fn use_alpha<'a>(_: &'a Alpha<'a, Impl>) {}

fn main() {
    for x in Vec::<Alpha<Impl>>::new().into_iter() {
        use_alpha(&x); // <-- ok
    }
}

计划＃2 - 有生命周期错误

trait Trait<'a> {
    type T;
}

struct Impl;

impl<'a> Trait<'a> for Impl {
    type T = std::marker::PhantomData<&'a ()>;
}

struct Alpha<'a, T: Trait<'a>> {
    _dummy: std::marker::PhantomData<(&'a (), T::T)>,
}

fn use_alpha<'a>(_: &'a Alpha<'a, Impl>) {}

fn main() {
    for x in Vec::<Alpha<Impl>>::new().into_iter() {
        use_alpha(&x); // <-- !error!
    }
}

这是第二个程序的编译时错误：

error: `x` does not live long enough
  --> src/main.rs:20:5
   |
19 |         use_alpha(&x); // <-- !error!
   |                    - borrow occurs here
20 |     }
   |     ^ `x` dropped here while still borrowed
   |
   = note: values in a scope are dropped in the opposite order they are created

这是两个程序的差异：

 #[derive(Clone)]
 struct Alpha<'a, T: Trait<'a>> {
-    _dummy: std::marker::PhantomData<(&'a (), T)>,
+    _dummy: std::marker::PhantomData<(&'a (), T::T)>,
 }

唯一的区别是，通过将第一个程序更改为使用关联类型而不是struct定义中的type参数，会发生生命周期错误。我不知道为什么会这样。据我所知，关联类型不应该产生任何额外的生命周期限制 - 它只是'a，但很明显Rust编译器不同意。

如果我用简单的实例化替换第二个程序的main函数中的迭代，那么生命周期错误就会消失。那就是：

fn main() {
    let x = Alpha::<Impl> { _dummy: std::marker::PhantomData };
    use_alpha(&x); // <-- ok in both programs
}

我不明白为什么迭代与直接实例化不同。

Answer 1

在use_alpha中，您使用相同的生命周期来引用Alpha及其生命周期参数。其生命周期参数将成为Impl Trait::T的生命周期。该注释提供了有关删除值的顺序的提示：Impl::T在Impl之前被删除，因为它是Impl定义的一部分，但这意味着Alpha的某些部分在它还在的时候已经被删除了。

您可以使用use_alpha中的两个生命周期参数来解决此问题：

fn use_alpha<'a, 'b>(_: &'a Alpha<'b, Impl>) {}

这将允许编译器为每种类型推断不同的生命周期。

使用相关类型的特征与生命周期参数的生命周期错误

1 个答案: