Question

我发现Rust打破了一些旧代码，我决心解决它。可悲的是，似乎终身参考已经发生了很大的变化，并且发生了一些奇怪的事情。字段Counter.data是无关紧要的，它只是用来表明我使用的是一些数据，它是对泛型内容的引用。

以下是代码：

struct Counter <'c, T: 'c> {
    val: u32,
    data: &'c T
}

struct CounterIterator<'c, T:'c> {
    iter: &'c mut Counter<'c, T>,
    num: u32
}

impl<'r, T> Iterator<u32> for CounterIterator<'r, T> {
    fn next(&mut self) -> Option<u32> {
        if self.num  == 0 {
            None
        } else {
            self.num -= 1;
            self.iter.incr()
        }
    }
}

impl<'c, T> Counter <'c, T> {
    fn new(dataz: &'c T) -> Counter<'c, T> {
        Counter {
            val: 0u32,
            data: dataz
        }
    }

    fn incr(&mut self) -> Option<u32> {
        self.val += 1;
        println!("{}", self.val);
        Some(self.val)
    }

    fn iter(&'c mut self, num: u32) -> CounterIterator<'c, T> {
        CounterIterator {
            iter: self,
            num: num
        }
    }
}

fn main() {
    let val = 11u;
    let mut cnt = Counter::new(&val);
    for i in range(0,2u) {
        cnt.incr();
    }

    for i in cnt.iter(3) {

    }

    cnt.incr(); // <- commenting this out "fixes" the problem
    // Otherwise the error is 
    // note: previous borrow of `cnt` occurs here; the mutable borrow prevents 
    // subsequent moves, borrows, or modification of `cnt` until the borrow ends

}

这里的错误是什么？我如何使这个'Iterator'成语在它退出循环时结束借用，而不是在它定义的块结束时？此外，显式生命时间T:'c做了什么？

对于记录我正在尝试使用类似于str.chars()的Iterator API。如果有更好的方法，请告诉我。

Answer 1

在fn iter中，&'c mut self将self的可变借用与'c的生命周期Counter联系起来。当你拨打cnt.incr()时，你无法借用cnt，因为...... cnt仍然存在（所以&'c mut self仍在借用它。）

使代码工作的一种可能方法是在data中移动Counter，而不是存储借用的引用，如下所示：

struct Counter <T> {
    val: u32,
    data: T
}

如果您想将数据作为参考，另一种方法是向CounterIterator结构引入第二个命名生命周期，以便对Counter的可变借用可以比Counter短。本身。

// we now have a shorter lifetime ('s) and a longer one ('l). This is 
// expressed to the compiler by the 'l: 's bound that says "'l lives 
// at least as long as 's"
struct CounterIterator<'s, 'l: 's, T: 'l> {
    iter: &'s mut Counter<'l, T>,
    num: u32
}

impl<'c,  T> Counter <'c, T> {
// ...
    // now the &mut self can live as long as CounterIterator, not necessarily as
    // long as Counter. This allows it to be released as soon as the iteration
    // is over and CounterIterator goes out of scope
    fn iter<'a>(&'a mut self, num: u32) -> CounterIterator<'a,'c, T> {
        CounterIterator {
            iter: self,
            num: num
        }
    }
}

供参考，因为语言仍然有些不稳定：

$ rustc -v
rustc 0.12.0-pre-nightly (2e3858179 2014-09-03 00:51:00 +0000)

生锈和老迭代器模式

1 个答案: