arrays - 以最小开销安全地将所有元素从通用数组移出到元组中的方法

Question

在 Rust 中，我想将所有元素移出通用固定宽度数组，这样我就可以单独 move 它们。这些元素可能但不一定要实现 Copy。我提出了以下解决方案:

struct Vec3<T> {
    underlying_array: [T; 3]
}

impl<T> Vec3<T> {
    fn into_tuple(self) -> (T, T, T) {
        let result = (
            unsafe { mem::transmute_copy(&self.underlying_array[0]) },
            unsafe { mem::transmute_copy(&self.underlying_array[1]) },
            unsafe { mem::transmute_copy(&self.underlying_array[2]) },
        );
        mem::forget(self);
        result
    }
}

它似乎有效，但我想知道在一般情况下它是否安全。来自 C++，通过复制对象的位模式和绕过源对象的析构函数来 move 对象通常是不安全的，我认为这基本上就是我在这里所做的。但是在 Rust 中，每种类型都是可 move 的(我认为)并且没有办法自定义 move 语义(我认为)，所以我想不出 Rust 在未优化的情况下实现 move 对象的任何其他方式，而不是按位复制.

像这样将元素移出数组安全吗？有没有更惯用的方法呢？ Rust 编译器是否足够聪明，可以在可能的情况下省略 transmute_copy 执行的实际位复制，如果没有，是否有更快的方法来执行此操作？

我认为这不是 How do I move values out of an array? 的副本因为在那个例子中，数组元素不是通用的，也没有实现 Drop。已接受答案中的库一次将单个值从数组中移出，同时保持数组的其余部分可用。因为我想一次 move 所有值而不关心保留数组，所以我认为这种情况有所不同。

Answer 1

Rust 1.36 及更高版本

这现在可以用完全安全的代码来完成:

impl<T> Vec3<T> {
    fn into_tuple(self) -> (T, T, T) {
        let [a, b, c] = self.underlying_array;
        (a, b, c)
    }
}

以前的版本

正如您在 How do I move values out of an array? 中提到和讨论的那样, 将泛型类型视为一堆比特可能非常危险。一旦我们复制了这些位并且它们是“实时的”，Drop 等特征的实现就可以在我们最不期望的时候访问该值。

也就是说，您当前的代码看起来 是安全的，但具有不必要的灵 active 。使用 transmute 或 transmute_copy 是大锤，实际上很少需要。您不希望能够更改值的类型。相反，使用 ptr::read .

扩展 unsafe block 以覆盖使某些内容安全的代码范围，然后包含解释为什么该 block 实际上是安全的注释是很常见的。在这种情况下，我会将其扩展以涵盖 mem::forget；返回的表达式也必须随之而来。

您需要确保在您移出第一个值和忘记数组之间不可能发生 panic 。否则，您的数组将初始化一半，您将触发未初始化的行为。在这种情况下，我喜欢你编写一个语句来创建结果元组的结构；在那里的额外代码中不小心塞进鞋拔更难。这也值得添加评论。

use std::{mem, ptr};

struct Vec3<T> {
    underlying_array: [T; 3],
}

impl<T> Vec3<T> {
    fn into_tuple(self) -> (T, T, T) {
        // This is not safe because I copied it directly from Stack Overflow
        // without reading the prose associated with it that said I should 
        // write my own rationale for why this is safe.
        unsafe {
            let result = (
                ptr::read(&self.underlying_array[0]),
                ptr::read(&self.underlying_array[1]),
                ptr::read(&self.underlying_array[2]),
            );
            mem::forget(self);
            result
        }
    }
}

fn main() {}

every type is movable

是的，我相信这是正确的。你可以make certain values immovable though (搜索“一个特定案例”。

there's no way to customize move semantics

是的，I believe this to be correct .

Is the Rust compiler smart enough to elide the actual bit copying

一般来说，我相信编译器会这样做，是的。然而，优化是一件棘手的事情。最终，只有查看真实案例中的汇编和分析才能告诉您真相。

is there a faster way to do this?

我不知道。

---

我通常会写这样的代码:

extern crate arrayvec;
extern crate itertools;

use arrayvec::ArrayVec;
use itertools::Itertools;

struct Vec3<T> {
    underlying_array: [T; 3],
}

impl<T> Vec3<T> {
    fn into_tuple(self) -> (T, T, T) {
        ArrayVec::from(self.underlying_array).into_iter().next_tuple().unwrap()
    }
}

调查两种实现的程序集，第一个需要 25 个 x86_64 指令，第二个需要 69 个。同样，我依靠分析来了解哪个更快，因为更多指令不会t 一定意味着更慢。

另见:

• How do I move values out of an array?
• How do I move String values from an array to a tuple without copying?