How to safely reinterpret Vec<f64> as Vec<num_complex::Complex<f64>> with half size?

Question

我通过外部 C 库（最好不要更改）以

Vec<f64>

的形式将复数数据填充到

[i_0_real, i_0_imag, i_1_real, i_1_imag, ...]

中，看起来这个

Vec<f64>

具有与一半的

Vec<num_complex::Complex<f64>>

相同的内存布局鉴于

num_complex::Complex<f64>

的数据结构与

[f64; 2]

的内存布局兼容，如here所述，长度将是。我想这样使用它而不需要重新分配一个可能很大的缓冲区。

我假设在

from_raw_parts()

中使用

std::vec::Vec

来伪造一个新的

Vec

是有效的，它拥有旧的

Vec

的记忆（通过忘记旧的

Vec

）并使用

size / 2

和

capacity / 2

，但这需要不安全的代码。是否有一种“安全”的方式来进行这种数据重新解释？

Vec

在 Rust 中分配为

Vec<f64>

并由使用

.as_mut_ptr()

填充

Vec<f64>

的 C 函数填充。

我当前的编译不安全实现：

extern crate num_complex;

pub fn convert_to_complex_unsafe(mut buffer: Vec<f64>) -> Vec<num_complex::Complex<f64>> {
    let new_vec = unsafe {
        Vec::from_raw_parts(
            buffer.as_mut_ptr() as *mut num_complex::Complex<f64>,
            buffer.len() / 2,
            buffer.capacity() / 2,
        )
    };
    std::mem::forget(buffer);
    return new_vec;
}

fn main() {
    println!(
        "Converted vector: {:?}",
        convert_to_complex_unsafe(vec![3.0, 4.0, 5.0, 6.0])
    );
}

Answer 1

是否有一种“安全”的方式来进行这种数据重新解释？

没有。至少，这是因为你需要知道的信息没有在 Rust 类型系统中表达，而是通过散文（也就是文档）表达：

Complex<T>

是与数组兼容的内存布局

[T; 2]

.

—

Complex

文档

如果一个

Vec

已经分配了内存，那么 [...] 它的指针指向

len

按顺序初始化的连续元素（如果你将它强制为一个切片你会看到什么），

—

Vec

文档

数组强制切片 (

[T]

)

— 数组文档

由于

Complex

与数组内存兼容，数组的数据与切片内存兼容，而

Vec

的数据与切片内存兼容，这种转换应该是安全的，即使编译器不能告诉这个。

此信息应附加（通过评论）到您的不安全块。

我会对你的功能做一些小的调整：

• 同时有两个

  Vec

  指向相同的数据让我非常紧张。这可以通过引入一些变量并在创建另一个之前忘记一个变量来避免。

• 删除

  return

  关键字更地道

• 添加一些断言数据的起始长度是二的倍数

• 正如 rodrigo 指出的，容量很可能是奇数。为了避免这种情况，我们调用

  shrink_to_fit

  。这样做的缺点是

  Vec

  may 需要重新分配和复制内存，具体取决于实现。

• 展开

  unsafe

  块以覆盖确保安全不变量得到维护所需的所有相关代码。

pub fn convert_to_complex(mut buffer: Vec<f64>) -> Vec<num_complex::Complex<f64>> {
    // This is where I'd put the rationale for why this `unsafe` block
    // upholds the guarantees that I must ensure. Too bad I
    // copy-and-pasted from Stack Overflow without reading this comment!
    unsafe {
        buffer.shrink_to_fit();

        let ptr = buffer.as_mut_ptr() as *mut num_complex::Complex<f64>;
        let len = buffer.len();
        let cap = buffer.capacity();

        assert!(len % 2 == 0);
        assert!(cap % 2 == 0);

        std::mem::forget(buffer);

        Vec::from_raw_parts(ptr, len / 2, cap / 2)
    }
}

为了避免所有关于容量的担忧，您可以将切片转换为

Vec

。这也没有任何额外的内存分配。它更简单，因为我们可以“丢失”任何奇数尾随值，因为

Vec

仍然保持它们。

pub fn convert_to_complex(buffer: &[f64]) -> &[num_complex::Complex<f64>] {
    // This is where I'd put the rationale for why this `unsafe` block
    // upholds the guarantees that I must ensure. Too bad I
    // copy-and-pasted from Stack Overflow without reading this comment!
    unsafe {
        let ptr = buffer.as_ptr() as *mut num_complex::Complex<f64>;
        let len = buffer.len();

        assert!(len % 2 == 0);
        
        std::slice::from_raw_parts(ptr, len / 2)
    }
}