为什么 RefCell 的 `into_inner` 需要移动？

Question

我有一种情况，我必须通过&mut self 将结构从一个对象移动到另一个对象。看看：

pub struct MyStruct {
    //no copy trait
    device: Device
}

impl MyStruct {
    pub fn finalize(&mut self) {
        //error: cannot move since I borrowed 
        let interface = InterfaceBuilder::new(self.device)
    }
}

首先，为什么我不能从借来的可变引用中移出一些东西？借用的可变数据是独占的，不可能有其他代码在调查它。

好吧，为了解决这个问题，我改为

pub struct MyStruct {
    //no copy trait
    device: RefCell<Device>
}

impl MyStruct {
    pub fn finalize(&mut self) {
        //error on `self.device`: cannot move out of `self.device` which is behind a mutable reference
        let interface = InterfaceBuilder::new(self.device.into_inner())
    }
} 

我知道为什么会发生错误：

pub fn into_inner(self) -> T

调用into_inner 使self.device 移动。为什么RefCell 根本没有实现pub fn into_inner(&mut self) -> T？我看不出有什么问题。

Answer 1

您不能移出可变引用，因为这会使原始对象不完整。

考虑这段代码：

struct MyStruct {
    s: String
}

fn finalize(f: &mut MyStruct) {
    let _x = f.s; //error E0507!
}

fn main() {
    let mut my = MyStruct {
        s: "hi".into()
    };
    finalize(&mut my);
    println!("{}", my.s); //what should this do?
}

那么，RefCell::into_inner(&mut self) -> T 也有同样的问题。你可以连续调用它两次，你会得到两个 T 值，而之前只有一个。而且，对于非 Copy 类型是不可能的。

如果你想让这个函数消耗内部值，可能它也应该消耗外部值：

fn finalize(f: MyStruct) {
    let _x = f.s;
}

如果你真的想从可变引用中移出一个值，你必须在它的位置留下一些有效的东西。最简单的方法是声明一个Option 并使用take() 窃取并用None 替换它：

struct MyStruct {
    s: Option<String>
}

fn finalize(f: &mut MyStruct) {
    let _x = f.s.take();
}

当然，Option::take 返回一个Option，所以如果你调用它两次，第二次你会得到None。如果你是肯定的，你有一个价值，你可以做take().uwnrap()。

或者，如果您的字段类型是 Default，您可以使用 std::mem::take 将其替换为默认创建的值：

struct MyStruct {
    s: Vec<i32>
}

fn finalize(f: &mut MyStruct) {
    let _x = std::mem::take(&mut f.s);
}

PS #1：有Cell::take(&self) -> T，但前提是T 实现Default。它的工作方式与 std::mem::take 类似，但引用不可变。

PS #2：还有unsafe fn ManuallyDrop::take(slot: &mut ManuallyDrop<T>) -> T，旨在用于高级drop 实现。但它是unsafe，所以它永远不应该是你的首选：如果你调用它两次，你会得到未定义的行为。