Question

请考虑以下代码：

#[derive(Clone)]
pub struct Stride<'a, I: Index<uint> + 'a> {
    items: I,
    len: uint,
    current_idx: uint,
    stride: uint,
}

impl<'a, I> Iterator for Stride<'a, I> where I: Index<uint> {
    type Item = &'a <I as Index<uint>>::Output;

    #[inline]
    fn next(&mut self) -> Option<&'a <I as Index<uint>>::Output> {
        if (self.current_idx >= self.len) {
            None
        } else {
            let idx = self.current_idx;
            self.current_idx += self.stride;
            Some(self.items.index(&idx))
        }
    }
}

这是当前的错误，表示编译器无法推断Some(self.items.index(&idx))行的适当生命周期。返回值的生命周期应该是多少？我认为它应该与self.items的生命周期相同，因为Index trait方法返回一个与Index实现者具有相同生命周期的引用。

Answer 1

Index的{{3}}是：

pub trait Index<Index: ?Sized> {
    type Output: ?Sized;
    /// The method for the indexing (`Foo[Bar]`) operation
    fn index<'a>(&'a self, index: &Index) -> &'a Self::Output;
}

具体而言，index返回对引用与self具有相同生命周期的元素的引用。也就是说，它借用了self。

在您的情况下，self调用的index（可能是&self.items[idx] btw）是self.items，因此编译器会看到返回值必须为限制为从self.items借用，但items归next self所有，因此从self.items借款是self借来的本身。

也就是说，编译器只能保证index的返回值只要self存在就有效（以及对变异的各种担忧），因此{{1}的生命周期并且必须链接返回的&mut self。

如果编译它，要查看错误，链接引用是编译器建议的内容：

&...

但是，建议的签名<anon>:23:29: 23:40 error: cannot infer an appropriate lifetime for autoref due to conflicting requirements <anon>:23 Some(self.items.index(&idx)) ^~~~~~~~~~~ <anon>:17:5: 25:6 help: consider using an explicit lifetime parameter as shown: fn next(&'a mut self) -> Option<&'a >::Output> <anon>:17 fn next(&mut self) -> Option<&'a >::Output> { <anon>:18 if (self.current_idx >= self.len) { <anon>:19 None <anon>:20 } else { <anon>:21 let idx = self.current_idx; <anon>:22 self.current_idx += self.stride; ...比fn next(&'a mut self) -> Option<&'a >::Output>特征的签名更具限制性，因此是非法的。（具有这种生命周期安排的迭代器可能很有用，但它们不适用于许多普通消费者，例如Iterator。）

编译器正在防范的问题由以下类型证明：

.collect

这会存储两个struct IndexablePair<T> { x: T, y: T } impl Index<uint> for IndexablePair<T> { type Output = T; fn index(&self, index: &uint) -> &T { match *index { 0 => &self.x, 1 => &self.y, _ => panic!("out of bounds") } } }内联（例如，直接在堆栈上）并允许对它们T和pair[0]建立索引。 pair[1]方法将指针直接返回到该存储器（例如堆栈），因此如果index值在存储器中移动，那么这些指针将变为无效，例如，（假设IndexablePair）：

Stride::new(items: I, len: uint, stride: uint)

那倒数第二行很糟糕！它使let pair = IndexablePair { x: "foo".to_string(), y: "bar".to_string() }; let mut stride = Stride::new(pair, 2, 1); let value = stride.next(); // allocate some memory and move stride into, changing its address let mut moved = box stride; println!("value is {}", value);无效，因为value及其字段stride（对）在内存中移动，因此items内的引用随后指向移动的数据;这是非常不安全和非常糟糕的。

建议的生命周期通过借用value并禁止此移动来阻止此问题（以及其他一些有问题的问题），但是，正如我们上面所见，我们无法使用它。

解决这个问题的技巧是将存储元素的内存与迭代器本身分开，即将stride的定义更改为：

Stride

（添加对pub struct Stride<'a, I: Index<uint> + 'a> { items: &'a I, len: uint, current_idx: uint, stride: uint, }的引用。）

编译器然后保证存储元素的内存独立于items值（即，在内存中移动Stride不会使旧元素无效）因为存在非元素分离它们的指针。这个版本编译好：

Stride

（理论上可以在那里添加use std::ops::Index; #[derive(Clone)] pub struct Stride<'a, I: Index<uint> + 'a> { items: &'a I, len: uint, current_idx: uint, stride: uint, } impl<'a, I> Iterator for Stride<'a, I> where I: Index<uint> { type Item = &'a >::Output; #[inline] fn next(&mut self) -> Option<&'a >::Output> { if (self.current_idx >= self.len) { None } else { let idx = self.current_idx; self.current_idx += self.stride; Some(self.items.index(&idx)) } } }绑定，可能是通过手动实现?Sized而不是Clone，这样derive可以直接用于Stride，即&[T] Stride::new(items: &I, ...)可以使用，而不是必须使用Stride::new(&[1, 2, 3], ...)的双层作为默认Stride::new(&&[1, 2, 3], ...)绑定所需的。）

definition

需要帮助了解迭代器的生命周期

1 个答案: