暂时搬出借来的内容

Question

我正在尝试替换可变借用中的值；将其中的一部分移入新值：

enum Foo<T> {
    Bar(T),
    Baz(T),
}

impl<T> Foo<T> {
    fn switch(&mut self) {
        *self = match self {
            &mut Foo::Bar(val) => Foo::Baz(val),
            &mut Foo::Baz(val) => Foo::Bar(val),
        }
    }
}

上面的代码不起作用，可以理解的是，将值移出self 会破坏它的完整性。但由于该值在之后立即被删除，我（如果不是编译器）可以保证它是安全的。

有什么方法可以实现吗？我觉得这是不安全代码的工作，但我不确定它会如何工作。

Answer 1

mem:uninitialized 自 Rust 1.39 起已被弃用，取而代之的是 MaybeUninit。

但是，这里不需要未初始化的数据。相反，您可以使用ptr::read 来获取self 引用的数据。

此时，tmp 拥有枚举中数据的所有权，但如果我们要删除 self，则该数据将尝试被析构函数读取，从而导致内存不安全。

然后我们执行转换并将值放回原处，恢复类型的安全性。

use std::ptr;

enum Foo<T> {
    Bar(T),
    Baz(T),
}

impl<T> Foo<T> {
    fn switch(&mut self) {
        // I copied this code from Stack Overflow without reading
        // the surrounding text that explains why this is safe.
        unsafe {
            let tmp = ptr::read(self);
    
            // Must not panic before we get to `ptr::write`

            let new = match tmp {
                Foo::Bar(val) => Foo::Baz(val),
                Foo::Baz(val) => Foo::Bar(val),
            };
    
            ptr::write(self, new);
        }
    }
}

此代码的更高级版本将防止恐慌从该代码冒泡出来，而是导致程序中止。

另见：

• replace_with，一个包装这个逻辑的箱子。
• take_mut，一个包装这个逻辑的箱子。
• Change enum variant while moving the field to the new variant
• How can I swap in a new value for a field in a mutable reference to a structure?

Answer 2

上面的代码不起作用，可以理解的是，移动值 出于自我破坏了它的完整性。

这并不是这里发生的事情。例如，与self 相同的事情会很好地工作：

impl<T> Foo<T> {
    fn switch(self) {
        self = match self {
            Foo::Bar(val) => Foo::Baz(val),
            Foo::Baz(val) => Foo::Bar(val),
        }
    }
}

Rust 对于部分和全部移动绝对没问题。这里的问题是你不拥有你试图移动的值——你只有一个可变的借用引用。您不能移出任何引用，包括可变引用。

这实际上是经常被要求的功能之一 - 一种特殊的参考，可以允许移出它。它将允许几种有用的模式。你可以找到更多here和here。

与此同时，在某些情况下，您可以使用std::mem::replace 和std::mem::swap。这些函数允许你从可变引用中“获取”一个值，前提是你提供一些东西作为交换。

Answer 3

好的，我想出了一点unsafeness 和std::mem 的方法。

我将self 替换为未初始化的临时值。由于我现在“拥有”了以前的 self，因此我可以安全地将值移出并替换它：

use std::mem;

enum Foo<T> {
    Bar(T),
    Baz(T),
}

impl<T> Foo<T> {
    fn switch(&mut self) {
        // This is safe since we will overwrite it without ever reading it.
        let tmp = mem::replace(self, unsafe { mem::uninitialized() });
        // We absolutely must **never** panic while the uninitialized value is around!

        let new = match tmp {
            Foo::Bar(val) => Foo::Baz(val),
            Foo::Baz(val) => Foo::Bar(val),
        };

        let uninitialized = mem::replace(self, new);
        mem::forget(uninitialized);
    }
}

fn main() {}