1 
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()

4

2 回答 2

2

借用检查器不可能在编译时证明这是正确的。但是你可以使用RefCell它来确保它在运行时工作，如果你做错了就会出现恐慌。除了在 Parent 对象中存储对对象的引用，您还可以存储RefMut允许您修改对象的 a。该bind函数采用对 a 的引用，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);
}
于 2015-11-06T08:55:51.823 回答
0

您还可以限定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);
于 2015-11-06T10:21:42.820 回答