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);
}

（ 游乐场）

有 2 个编译错误，第 36 行的错误对我来说很难修复，但第 34 行的第一个错误真的很奇怪，它说生命周期不能超过，因为方法调用是内部的，什么都没有。

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

Answer 1

通过对我来说突出的部分，以下是我可能会做出的改变。

结构

通过您拥有的两个结构，第一个看起来很合理。

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

但是， Val结构对我来说没有多大意义。 如果参照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尽管对它的可变引用仍在使用中。 这是相当不言自明的，所以我不会详细介绍。

安全防锈

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