rust - 在Rust中，如何创建可变的迭代器？ [复制]

Question

This question already has answers here:

How to implement Iterator yielding mutable references

(2个答案)


7个月前关闭。




尝试在安全的Rust中创建可变的迭代器时，我的生存期遇到了困难。
这是我将问题简化为的内容:

struct DataStruct<T> {
    inner: Box<[T]>,
}

pub struct IterMut<'a, T> {
    obj: &'a mut DataStruct<T>,
    cursor: usize,
}

impl<T> DataStruct<T> {
    fn iter_mut(&mut self) -> IterMut<T> {
        IterMut { obj: self, cursor: 0 }
    }
}

impl<'a, T> Iterator for IterMut<'a, T> {
    type Item = &'a mut T;

    fn next(&mut self) -> Option<Self::Item> {
        let i = f(self.cursor);
        self.cursor += 1;
        self.obj.inner.get_mut(i)
    }
}

fn f(i: usize) -> usize {
   // some permutation of i
}

我的 DataStruct的结构永远不会改变，但是我需要能够使存储在其中的元素的内容发生变异。例如，

let mut ds = DataStruct{ inner: vec![1,2,3].into_boxed_slice() };
for x in ds {
  *x += 1;
}

编译器给我一个有关我要返回的引用的生存期冲突的错误。它发现我不期望的生存期是 next(&mut self)函数的范围。
如果我尝试在 next()上注释生命周期，那么编译器会告诉我我不满足Iterator特质。这可以安全地解决 rust 吗？
这是错误:

error[E0495]: cannot infer an appropriate lifetime for autoref due to conflicting requirements
  --> src/iter_mut.rs:25:24
   |
25 |         self.obj.inner.get_mut(i)
   |                        ^^^^^^^
   |
note: first, the lifetime cannot outlive the anonymous lifetime #1 defined on the method body at 22:5...
  --> src/iter_mut.rs:22:5
   |
22 | /     fn next(&mut self) -> Option<Self::Item> {
23 | |         let i = self.cursor;
24 | |         self.cursor += 1;
25 | |         self.obj.inner.get_mut(i)
26 | |     }
   | |_____^
note: ...so that reference does not outlive borrowed content
  --> src/iter_mut.rs:25:9
   |
25 |         self.obj.inner.get_mut(i)
   |         ^^^^^^^^^^^^^^
note: but, the lifetime must be valid for the lifetime `'a` as defined on the impl at 19:6...
  --> src/iter_mut.rs:19:6
   |
19 | impl<'a, T> Iterator for IterMut<'a, T> {
   |      ^^
note: ...so that the types are compatible
  --> src/iter_mut.rs:22:46
   |
22 |       fn next(&mut self) -> Option<Self::Item> {
   |  ______________________________________________^
23 | |         let i = self.cursor;
24 | |         self.cursor += 1;
25 | |         self.obj.inner.get_mut(i)
26 | |     }
   | |_____^
   = note: expected  `std::iter::Iterator`
              found  `std::iter::Iterator`

编辑:

更改了next()的实现，以便迭代顺序是原始序列的排列。

最佳答案

借用检查器无法证明后续对next()的调用不会访问相同的数据。之所以出现这个问题，是因为借用的生命周期是迭代器生命周期的持续时间，因此无法证明不会在同一时间对同一个数据进行两个可变的引用。
如果没有不安全的代码，或者更改数据结构，确实没有办法解决此问题。您可以做slice::split_at_mut的等价物，但是，由于您不能对原始数据进行突变，因此无论如何都必须在不安全的代码中实现它。一个不安全的实现可能看起来像这样:

impl<'a, T> Iterator for IterMut<'a, T> {
    type Item = &'a mut T;

    fn next(&mut self) -> Option<Self::Item> {
        let i = self.cursor;
        self.cursor += 1;
        if i < self.obj.inner.len() {
            let ptr = self.obj.inner.as_mut_ptr();
            unsafe {
                Some(&mut *ptr.add(i))
            }
        } else {
            None
        }
    }
}

关于rust - 在Rust中，如何创建可变的迭代器？ [复制]，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/63437935/

上一篇：rust - 如何获取 rc::Ref<T> 对 rc::Weak<RefCell<T>> 指向的节点的引用？

下一篇：module - 何时/为什么需要导入 Rust 特征 `use` d/Imported

Answer 1

借用检查器无法证明后续对next()的调用不会访问相同的数据。之所以出现这个问题，是因为借用的生命周期是迭代器生命周期的持续时间，因此无法证明不会在同一时间对同一个数据进行两个可变的引用。
如果没有不安全的代码，或者更改数据结构，确实没有办法解决此问题。您可以做slice::split_at_mut的等价物，但是，由于您不能对原始数据进行突变，因此无论如何都必须在不安全的代码中实现它。一个不安全的实现可能看起来像这样:

impl<'a, T> Iterator for IterMut<'a, T> {
    type Item = &'a mut T;

    fn next(&mut self) -> Option<Self::Item> {
        let i = self.cursor;
        self.cursor += 1;
        if i < self.obj.inner.len() {
            let ptr = self.obj.inner.as_mut_ptr();
            unsafe {
                Some(&mut *ptr.add(i))
            }
        } else {
            None
        }
    }
}