首页 文章

在Rust结构中使用自引用封装顺序初始化状态

提问于
浏览 次
11

我正在尝试定义一个结构，它可以充当 Vec 中保存的 Vec 的迭代器：

use std::slice::Iter;
use std::cell::Ref;
use std::cell::RefCell;

struct HoldsVecInRefCell {
    vec_in_refcell: RefCell<Vec<i32>>,
}

// TODO: struct HoldsVecInRefCellIter implementing Iterator ...

impl HoldsVecInRefCell {
    fn new() -> HoldsVecInRefCell {
        HoldsVecInRefCell { vec_in_refcell: RefCell::new(Vec::new()) }
    }

    fn add_int(&self, i: i32) {
        self.vec_in_refcell.borrow_mut().push(i);
    }

    fn iter(&self) -> HoldsVecInRefCellIter {
        // TODO ...
    }
}

fn main() {
    let holds_vec = HoldsVecInRefCell::new();
    holds_vec.add_int(1);
    holds_vec.add_int(2);
    holds_vec.add_int(3);

    let mut vec_iter = holds_vec.iter();  // Under the hood: run-time borrow check

    for i in vec_iter {
        println!("{}", i);
    }
}

相比之下， vec_iter 可以在 main() 中在线初始化，如下所示（故意详细）：

// Elided: lifetime parameter of Ref
let vec_ref: Ref<Vec<i32>> = holds_vec.vec_in_refcell.borrow();
// Elided: lifetime parameter of Iter
let mut vec_iter: Iter<i32> = vec_ref.iter();

有没有办法定义一个实现 Iterator 的结构，它同时包含 Ref （保持不可变 RefCell 借用）和 Iter （保持 next() 的迭代器状态，而不是为 Vec 或其他任何容器滚动我自己的迭代器），当时第二个是从第一个派生出来的（并且持有从中获得的参考）？

我已经尝试了几种方法来实现这一点，并且所有方法都与借用检查器发生冲突 . 如果我把两个状态都作为裸结构成员，就像

struct HoldsVecInRefCellIter<'a> {
    vec_ref: Ref<'a, Vec<i32>>,
    vec_iter: Iter<'a, i32>,
}

然后我无法使用 HoldsVecInRefCellIter { ... } 语法一次初始化两个字段（例如，参见Does Rust have syntax for initializing a struct field with an earlier field?） . 如果我尝试用类似的结构分流顺序初始化

struct HoldsVecInRefCellIter<'a> {
    vec_ref: Ref<'a, Vec<i32>>,
    vec_iter: Option<Iter<'a, i32>>,
}

// ...

impl HoldsVecInRefCell {
    // ...

    fn iter(&self) -> HoldsVecInRefCellIter {
        let mut new_iter = HoldsVecInRefCellIter { vec_ref: self.vec_in_refcell.borrow(), vec_iter: None };
        new_iter.vec_iter = new_iter.vec_ref.iter();
        new_iter
    }
}

然后我招致一个可变的自我借用的结构，阻止从 iter() 返回它 . 如果您尝试在结构本身（Why can't I store a value and a reference to that value in the same struct?）中存储对结构的一部分的引用，则也会发生结构的自行借用，这会阻止安全地移动结构的实例 . 相比之下，它看起来像一个类似 HoldsVecInRefCellIter 的结构，如果你可以完成初始化，那么在移动时会做正确的事情，因为内部的所有引用都是在其他地方的数据超过了这个结构 .

有一些技巧可以避免使用 Rc 创建自引用（参见https://internals.rust-lang.org/t/self-referencing-structs/418/3中的示例），但是我不知道如果你想存储一个现有的 Iterator 结构来实现它们，这个结构被实现为保存对底层容器的直接引用，而不是 Rc .

作为一个来自C的Rust新手，这感觉就像一个经常出现的问题（“我在一个代码块中有一些复杂的状态初始化逻辑，我想抽象出那个逻辑并将结果状态保存在一个结构中使用”） .

Related Question: Returning iterator of a Vec in a RefCell

rust

1 回答

  • 6

    我们必须在生命中作弊和撒谎 .

    use std::mem;

struct HoldsVecInRefCellIter<'a> {
    vec_ref: Ref<'a, Vec<i32>>,
    vec_iter: Iter<'a, i32>, // 'a is a lie!
}

impl HoldsVecInRefCell {
    fn iter(&self) -> HoldsVecInRefCellIter {
        unsafe {
            let vec_ref = self.vec_in_refcell.borrow();
            // transmute changes the lifetime parameter on the Iter
            let vec_iter = mem::transmute(vec_ref.iter());
            HoldsVecInRefCellIter { vec_ref: vec_ref, vec_iter: vec_iter }
        }
    }
}

impl<'a> Iterator for HoldsVecInRefCellIter<'a> {
    type Item = i32;

    fn next(&mut self) -> Option<Self::Item> {
        self.vec_iter.next().cloned()
    }
}

    这只能起作用，因为 Iter 不会因为移动_983123而失效，因为 Ref 指向 Vec ， Iter 指向 Vec 的存储，而不是 Ref 本身 .

    但是，这也使您能够将 vec_iter 移出 HoldsVecInRefCellIter ;如果你提取 vec_iter 并删除 vec_ref ，则借用将被释放并且 Iter 可能无效而没有Rust给出编译器错误（ 'a 是 RefCell 's lifetime). With proper encapsulation, you can keep the struct' s内容私有并且避免用户执行此不安全操作 .

    顺便说一句，我们也可以定义迭代器来返回引用：

    impl<'a> Iterator for HoldsVecInRefCellIter<'a> {
    type Item = &'a i32;

    fn next(&mut self) -> Option<Self::Item> {
        self.vec_iter.next()
    }
}
    回复于

相关问题