迭代器返回引用的项，生命周期问题

Question

迭代器返回引用的项，生命周期问题

12

我有一个生命周期问题，我正在尝试实现一个通过引用返回其项的迭代器，以下是代码：

struct Foo {
   d: [u8; 42],
   pos: usize
}

impl<'a> Iterator<&'a u8> for Foo {
   fn next<'a>(&'a mut self) -> Option<&'a u8> {
      let r = self.d.get(self.pos);
      if r.is_some() {
         self.pos += 1;
      }
      r
   }
}

fn main() {
   let mut x = Foo {
      d: [1; 42],
      pos: 0
   };

   for i in x {
      println!("{}", i);
   }
}

然而，这段代码无法正确编译，出现了与参数生命周期相关的问题，以下是相应的错误：

$ rustc test.rs
test.rs:8:5: 14:6 error: method `next` has an incompatible type for trait: expected concrete lifetime, but found bound lifetime parameter
test.rs:8     fn next<'a>(&'a mut self) -> Option<&'a u8> {
test.rs:9         let r = self.d.get(self.pos);
test.rs:10         if r.is_some() {
test.rs:11             self.pos += 1;
test.rs:12         }
test.rs:13         r
           ...
test.rs:8:49: 14:6 note: expected concrete lifetime is the lifetime 'a as defined on the block at 8:48
test.rs:8     fn next<'a>(&'a mut self) -> Option<&'a u8> {
test.rs:9         let r = self.d.get(self.pos);
test.rs:10         if r.is_some() {
test.rs:11             self.pos += 1;
test.rs:12         }
test.rs:13         r
           ...
error: aborting due to previous error

有没有人有解决这个问题并仍然返回项的引用的想法？

至少这条消息是什么意思：期望具体的生命周期，但发现绑定的生命周期参数？

- user3762625

1个回答

网页内容由stack overflow 提供, 点击上面的

可以查看英文原文，
原文链接

- Chris Morgan · Accepted Answer

Note on the version of Rust used: at the time this question and answer were written, the Iterator trait used generics; it has changed to use associated types and is now defined thus:
pub trait Iterator {
    type Item;

    fn next(&mut self) -> Option<Self::Item>;
    …
}
And so the incorrect implementation shown here would be like this:
impl<'a> Iterator for Foo {
    type Item = &'a u8;

    fn next<'a>(&'a mut self) -> Option<&'a u8>;
}
In practical terms this affects nothing; it is merely that A becomes Self::Item.

迭代器（Iterator）特质的定义如下：

pub trait Iterator<A> {
    fn next(&mut self) -> Option<A>;
    …
}

请注意：fn next(&mut self) -> Option<A>。

下面是你拥有的：

impl<'a> Iterator<&'a u8> for Foo {
    fn next<'a>(&'a mut self) -> Option<&'a u8>;
}

请注意：fn next<'a>(&'a mut self) -> Option<&'a u8>。

这里存在几个问题：

1. 你引入了一个新的泛型参数<'a>，但实际上它不应该存在。为了方便起见并强调发生的情况，我将在impl块中定义的'a称为ρ₀，并将在方法中定义的'a称为ρ₁。它们不相同。 2. &mut self的生命周期与特征不同。

3. 返回类型的生命周期与特征不同：其中A是&'ρ₀ u8，而返回类型在A的位置上使用&'ρ₁ u8。它期望具体的生命周期ρ₀，但实际上找到的是生命周期ρ₁。（我不确定“bound”是什么意思，所以我会保持沉默，以免我错了。）

这就是问题所在：你不能将要迭代的对象的生命周期连接到&mut self。相反，它必须绑定到你正在为其实现特征的类型中的某个东西。例如，通过创建连接到基本切片的新迭代器对象来迭代切片中的项目，impl<'a, T> Iterator<&'a T> for Items<'a, T>。换句话说，如果你正在生成引用，则迭代特征的设计方式不是为了在self中返回某些东西，而是为了在你拥有引用的另一个对象内部返回某些东西。

对于你的特定、可能是简单的例子，你应该停止产生引用，或者改变它，使你的迭代器对象不包含你正在迭代的数据，让它仅仅包含对它的引用，例如：&'a [T] 或者类似Items<'a, T>的东西。