Rust:生命周期的错误使用

Question

我用生命周期测试了一个小例子，但有时我无法理解这个问题，就像这里:

struct Space<'r> {
    v: &'r mut usize,
    z: usize,
}

impl<'r> Space<'r> {
    fn new(v: &'r mut usize) -> Self {
        Self { v, z: 0 }
    }
    
    fn add(&'r mut self) {
        self.z += 1;
        *self.v = self.z
    }

    fn make_val(&'r mut self, v: u32) -> Val<'r> {
        Val::new(self, v)
    }
}

struct Val<'r> {
    space: &'r mut Space<'r>,
    v: u32,
}

impl<'r> Val<'r> {
    fn new(space: &'r mut Space<'r>, v: u32) -> Self {
        Self { space, v }
    }
}

impl<'r> Clone for Val<'r> {
    fn clone(&self) -> Self {
        self.space.add();
        
        Self { space: self.space, v: self.v }
    }
}

fn main() {
    let mut v = 0usize;
    let mut space = Space::new(&mut v);
    let mut val1 = space.make_val(1234);
    let mut val2 = val1.clone();
    
    println!("Res: {} - {}/{}", v, val1.v, val2.v);
}

( Playground )

有 2 个编译错误，第 36 行的错误对我来说很难修复，但第 34 行的第一个错误真的很奇怪，它说生命周期不能长于方法调用是内部的，没有任何外部调用。

你能解释一下这些问题以及如何解决它们吗？

Answer 1

回顾一下对我来说最突出的部分，以下是我可能会做出的改变。

结构

仔细检查您拥有的两个结构，第一个看起来很合理。

struct Space<'r> {
    v: &'r mut usize,
    z: usize,
}

然而，Val struct 对我来说意义不大。如果引用Space具有相同的生命周期 'r作为 Space本身，那么它本质上等同于移动Val<'r>进入Space<'r> .虽然不违法，但我建议更改它。

// Just claim Space<'r> completely
struct Val<'r> {
    space: Space<'r>,
    v: u32,
}

另一种选择是为 Val<'r> 添加额外的生命周期这样make_val可以多次调用而不会导致生命周期冲突。

// life of reference to space 'a <= 'r
struct Val<'a, 'r: 'a> {
    space: &'a mut Space<'r>,
    v: u32,
}

// Modify to allow for second lifetime to be used.
fn make_val<'a>(&'a mut self, v: u32) -> Val<'a, 'r> {
    Val { space: self, v }
}

Space::add

&'r mut self 上的显式生命周期不是函数运行所必需的。在尝试运行代码时遇到的两个错误中，整个第一个错误只是编译器告诉您为什么这行不通。它过度限制了函数并且不必要地混淆了编译器，所以让我们删除它。

fn add(&mut self) {
    self.z += 1;
    *self.v = self.z
}

无法解决的原因是&mut self实际上是您要求相等的两个生命周期。如果我们可视化所有涉及的生命周期可能更有意义:

// add(&mut self) tells the compiler to infer a lifetime for 'a that doesn't exceed 'b
fn add<'a, 'b: 'a>(self: &'a mut Space<'b>) {}

// add(&'r mut self) tells the compiler that the reference must live as long as the data 
fn add<'b>(self: &'b mut Space<'b>) {}

克隆

克隆包含可变引用的东西没有意义。 Rust 非常明确地禁止在内存中的任何给定点对某物进行多个可变引用。克隆引用在技术上是可行的，但需要不安全的代码。你不应该这样做，但我还是在下面写了它。

impl<'r> Clone for Val<'r> {
    fn clone(&self) -> Val<'r> {
        unsafe {
            // Make self mutable so we can access self.space
            let my_self: &mut Self = &mut *(self as *const _ as *mut _);

            // Requires a mutable reference to self to run space::add
            my_self.space.add();
        
            Self {
                // Duplicate reference via unsafe code
                space: &mut *my_self.space,
                v: self.v
            }
        }
    }
}

打印

最后，main中的打印行使用v尽管对它的可变引用仍在使用中。这是不言自明的，所以我不会详细介绍。

安全使用rust

解决这个问题的安全方法是使用Rc<Refcell<T>> . Rc允许跨单个线程和 RefCell 获取多个拥有的引用允许内部可变性。 RefCell能够通过在运行时而不是编译时检查是否存在任何其他引用来做到这一点。这是 playground 的一个版本适用于单个 RefCell , 但也可以使用第二个来更好地匹配您的原始代码。