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

迈克·佩德森

我已经在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返回可变引用。

用代码链接到游乐场

卖力

您无法编译此代码,因为可变引用比不可变引用更具限制性。简短的版本说明了这个问题,它是:

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归Y拥有)创建对X的可变引用,则最好确保只要存在对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过借用。很好 这意味着现在只有一种到达内存位置的方法ip

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

解决您的问题的简单方法可能是依靠MutItems这已经是库在向量上提供的可变迭代器。因此,您可能只使用它而不是自己的自定义类型就可以摆脱困境,或者可以将其包装在自定义迭代器类型中。如果由于某种原因而不能这样做,则必须编写自己的不安全代码。如果这样做,请确保

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

本文收集自互联网,转载请注明来源。

如有侵权,请联系 [email protected] 删除。

编辑于
0

我来说两句

0 条评论
登录 后参与评论

相关文章