暂时持有借来的物品

Question

struct Parent<'a> {
    inner: Option<&'a mut Object>
}
impl<'a> Parent<'a> {
    fn new() -> Parent<'a> {
        Parent {
            inner: None,
        }
    }
    fn bind(&mut self, obj: &'a mut Object) {
        self.inner = Some(obj);
    }
    fn unbind(&mut self) {
        self.inner = None;
    }
}
struct Object {
    inner: u32,
}
fn main() {
    let mut obj = Object { inner: 0 };
    let mut parent1 = Parent::new();
    let mut parent2 = Parent::new();
    parent1.bind(&mut obj);
    parent1.unbind();
    // parent2.bind(&mut obj);
    // ^ error

}

结构 Parent 字段必须存储 Option:

struct Parent {
    inner: Option</*  magic  */>
}

有必要暂时阻止使用 fn main() 中的对象的可能性，直到您调用 .unbind()

Answer 1

借用检查器不可能在编译时证明这是正确的。但是你可以使用 RefCell 来确保它在运行时有效，如果你做错了会出现恐慌。您可以存储一个允许您修改对象的 RefMut，而不是在 Parent 对象中存储对该对象的引用。 bind 函数引用了一个 RefCell 并且如果该对象已经被借用将会恐慌。

use std::cell::*;

struct Parent<'a> {
    inner: Option<RefMut<'a, Object>>,
}
impl<'a> Parent<'a> {
    fn new() -> Parent<'a> {
        Parent {
            inner: None,
        }
    }
    fn bind(&mut self, obj: &'a RefCell<Object>) {
        self.inner = Some(obj.borrow_mut());
    }
    fn unbind(&mut self) {
        self.inner = None;
    }
}
struct Object {
    inner: u32,
}
fn main() {
    let obj = RefCell::new(Object { inner: 0 });
    let mut parent1 = Parent::new();
    parent1.bind(&obj);
    parent1.unbind(); // comment this line out and you get a runtime panic
    let mut parent2 = Parent::new();
    parent2.bind(&obj);
}

Answer 2

您还可以限定 parent1 的使用范围。一旦你将 obj 绑定到 parent2，它就不能再被 parent1 使用了：

let mut obj = Object { inner: 0 };
{
    let mut parent1 = Parent::new();
    parent1.bind(&mut obj);
    parent1.unbind();
}
let mut parent2 = Parent::new();
parent2.bind(&mut obj);

暂时持有借来的物品

To temporarily hold the borrowed object

mutability

rust

borrow-checker

borrowing