如何使用返回可变引用的迭代器创建自己的数据结构？

Posted 2023-02-19

【中文标题】如何使用返回可变引用的迭代器创建自己的数据结构？

【英文标题】：How can I create my own data structure with an iterator that returns mutable references?

【发布时间】：2014-11-02 01:06:36

【问题描述】：

我在 Rust 中创建了一个数据结构，我想为它创建迭代器。不可变迭代器很容易。我目前有这个，它工作正常：

// This is a mock of the "real" EdgeIndexes class as
// the one in my real program is somewhat complex, but
// of identical type

struct EdgeIndexes;

impl Iterator for EdgeIndexes 
    type Item = usize;
    fn next(&mut self) -> Option<Self::Item> 
        Some(0)
    

    fn size_hint(&self) -> (usize, Option<usize>) 
        (0, None)
    


pub struct CGraph<E> 
    nodes: usize,
    edges: Vec<E>,


pub struct Edges<'a, E: 'a> 
    index: EdgeIndexes,
    graph: &'a CGraph<E>,


impl<'a, E> Iterator for Edges<'a, E> 
    type Item = &'a E;

    fn next(&mut self) -> Option<Self::Item> 
        match self.index.next() 
            None => None,
            Some(x) => Some(&self.graph.edges[x]),
        
    

    fn size_hint(&self) -> (usize, Option<usize>) 
        self.index.size_hint()
    

我想创建一个返回可变引用的迭代器。我试过这样做，但找不到编译的方法：

pub struct MutEdges<'a, E: 'a> 
    index: EdgeIndexes,
    graph: &'a mut CGraph<E>,


impl<'a, E> Iterator for MutEdges<'a, E> 
    type Item = &'a mut E;

    fn next(&mut self) -> Option<&'a mut E> 
        match self.index.next() 
            None => None,
            Some(x) => self.graph.edges.get_mut(x),
        
    

    fn size_hint(&self) -> (usize, Option<usize>) 
        self.index.size_hint()
    

编译它会导致以下错误：

error[E0495]: cannot infer an appropriate lifetime for lifetime parameter in function call due to conflicting requirements
  --> src/lib.rs:54:24
   |
54 |             Some(x) => self.graph.edges.get_mut(x),
   |                        ^^^^^^^^^^^^^^^^
   |
note: first, the lifetime cannot outlive the anonymous lifetime #1 defined on the method body at 51:5...
  --> src/lib.rs:51:5
   |
51 | /     fn next(&mut self) -> Option<&'a mut E> 
52 | |         match self.index.next() 
53 | |             None => None,
54 | |             Some(x) => self.graph.edges.get_mut(x),
55 | |         
56 | |     
   | |_____^
note: ...so that reference does not outlive borrowed content
  --> src/lib.rs:54:24
   |
54 |             Some(x) => self.graph.edges.get_mut(x),
   |                        ^^^^^^^^^^^^^^^^
note: but, the lifetime must be valid for the lifetime 'a as defined on the impl at 48:6...
  --> src/lib.rs:48:6
   |
48 | impl<'a, E> Iterator for MutEdges<'a, E> 
   |      ^^
   = note: ...so that the expression is assignable:
           expected std::option::Option<&'a mut E>
              found std::option::Option<&mut E>

我不确定如何解释这些错误以及如何更改我的代码以允许 MutEdges 返回可变引用。

链接到playground with code。

【问题讨论】：

我不确定，但可能和***.com/questions/25702909/…是同一个问题

不完全是，我想。我的迭代器不拥有它返回可变引用的对象，而那个对象拥有。我认为有可能考虑到 Rust 标准库already has iterators of mutable references

他们的实现使用了不推荐使用的函数mut_shift_ref()，也许你可以在那里找到你需要的东西：doc.rust-lang.org/std/slice/…

我认为你所做的简化为：is.gd/jLTaTt。仍然不知道如何解决它，但它可以让其他人更容易。

@Levans：他们的实现不使用mut_shift_ref。只需点击文档中的[src]按钮即可查看MutItems的源代码。

【参考方案1】：

您无法编译它，因为可变引用比不可变引用更具限制性。说明该问题的缩短版本是这样的：

struct MutIntRef<'a> 
    r: &'a mut i32


impl<'a> MutIntRef<'a> 
    fn mut_get(&mut self) -> &'a mut i32 
        &mut *self.r
    


fn main() 
    let mut i = 42;
    let mut mir = MutIntRef  r: &mut i ;
    let p = mir.mut_get();
    let q = mir.mut_get();
    println!(", ", p, q);

产生同样的错误：

error[E0495]: cannot infer an appropriate lifetime for borrow expression due to conflicting requirements
 --> src/main.rs:7:9
  |
7 |         &mut *self.r
  |         ^^^^^^^^^^^^
  |
note: first, the lifetime cannot outlive the anonymous lifetime #1 defined on the method body at 6:5...
 --> src/main.rs:6:5
  |
6 | /     fn mut_get(&mut self) -> &'a mut i32 
7 | |         &mut *self.r
8 | |     
  | |_____^
note: ...so that reference does not outlive borrowed content
 --> src/main.rs:7:9
  |
7 |         &mut *self.r
  |         ^^^^^^^^^^^^
note: but, the lifetime must be valid for the lifetime 'a as defined on the impl at 5:6...
 --> src/main.rs:5:6
  |
5 | impl<'a> MutIntRef<'a> 
  |      ^^
note: ...so that reference does not outlive borrowed content
 --> src/main.rs:7:9
  |
7 |         &mut *self.r
  |         ^^^^^^^^^^^^

如果我们看一下 main 函数，我们会得到两个名为 p 和 q 的可变引用，它们都将内存位置称为 i。这是不允许的。在 Rust 中，我们不能有两个具有别名且都可用的可变引用。这种限制的动机是观察到突变和混叠在内存安全方面不能很好地协同工作。所以，编译器拒绝代码是件好事。如果这样编译，很容易出现各种内存损坏错误。

Rust 避免这种危险的方法是保持最多 一个 可变引用可用。因此，如果您想基于对 Y 的可变引用创建对 X 的可变引用，其中 X 归 Y 所有，我们最好确保只要对 X 的引用存在，我们就不能再触及对 Y 的其他引用.在 Rust 中，这是通过生命周期和借用来实现的。在这种情况下，编译器认为原始引用是借用的，这也会影响结果引用的生命周期参数。如果我们改变

fn mut_get(&mut self) -> &'a mut i32 
    &mut *self.r

到

fn mut_get(&mut self) -> &mut i32  // <-- no 'a anymore
    &mut *self.r // Ok!

编译器不再抱怨这个get_mut 函数。它现在返回一个引用，其生命周期参数与 &self 匹配，而不是 'a。这使得mut_get 成为您“借用”self 的函数。这就是编译器抱怨不同位置的原因：

error[E0499]: cannot borrow `mir` as mutable more than once at a time
  --> src/main.rs:15:13
   |
14 |     let p = mir.mut_get();
   |             --- first mutable borrow occurs here
15 |     let q = mir.mut_get();
   |             ^^^ second mutable borrow occurs here
16 |     println!(", ", p, q);
   |                        - first borrow later used here

显然，编译器确实确实考虑过借用mir。这很好。这意味着现在只有一种方法可以到达i的内存位置：p。

现在您可能想知道：标准库的作者是如何编写可变向量迭代器的？答案很简单：他们使用了不安全的代码。没有其他办法。 Rust 编译器根本不知道，每当您向可变向量迭代器请求下一个元素时，您每次都会获得不同的引用，而不会两次获得相同的引用。当然，我们知道这样的迭代器不会给你相同的引用两次，这使得提供这种你习惯的接口是安全的。我们不需要“冻结”这样的迭代器。如果迭代器返回的引用不重叠，则 不必 必须借用迭代器来访问元素是安全的。在内部，这是使用不安全代码完成的（将原始指针转换为引用）。

解决您的问题的简单解决方案可能是依赖MutItems。这已经是一个库提供的基于向量的可变迭代器。因此，您可能只使用它而不是您自己的自定义类型，或者您可以将它包装在您的自定义迭代器类型中。如果由于某种原因您不能这样做，您将不得不编写自己的不安全代码。如果这样做，请确保

您不会创建多个具有别名的可变引用。如果你这样做了，这将违反 Rust 规则并调用未定义的行为。 您不要忘记使用 PhantomData 类型告诉编译器您的迭代器是一种类似引用的类型，在这种类型中不允许用更长的生命周期替换生命周期，否则可能会创建一个悬空迭代器。