Question

我想转换数组。

示例：

func()-> *mut *mut f32;
...
let buffer = func();
for n in 0..48000 {
    buffer[0][n] = 1.0;
    buffer[1][n] = 3.0;
}

Answer 1

在Rust &[T] / &mut [T]中称为切片。切片不是数组;它是一个指向数组开头的指针，是该数组中的项数。因此，要从&mut [T]创建*mut T，您需要知道指针后面的数组长度。

*mut *mut T看起来像是2D（可能是锯齿状）数组的C实现，即数组数组（这与连续的2D数组不同，您可能知道）。没有免费的方法将其转换为&mut [&mut [T]]，因为正如我之前所说，*mut T是一个指针大小的数字，而&mut [T]是两个指针大小的数字。因此，您无法将*mut T转换为&mut [T]，这将是一个大小不匹配的问题。因此，由于布局不匹配，您无法简单地将*mut *mut f32转换为&mut [&mut [f32]]。

为了安全地处理存储在*mut *mut f32中的数字，首先需要确定外部数组的长度和所有内部数组的长度。为简单起见，我们认为它们都是静态知道的：

const ROWS: usize = 48000;
const COLUMNS: usize = 48000;

现在，既然知道了长度，就可以将外部指针转换为原始指针切片：

use std::slice;

let buffer: *mut *mut f32 = func();

let buf_slice: &mut [*mut f32] = unsafe {
    slice::from_raw_parts_mut(buffer, ROWS);
};

现在您需要浏览此切片并将每个项目转换为切片，将结果收集到矢量中：

let matrix: Vec<&mut [f32]> = buf_slice.iter_mut()
    .map(|p| unsafe { slice::from_raw_parts_mut(p, COLUMNS) })
    .collect();

现在您确实可以通过索引访问缓冲区：

for n in 0..COLUMNS {
    matrix[0][n] = 1.0;
    matrix[1][n] = 3.0;
}

（为了便于阅读，我在绑定上放置了显式类型，其中大多数实际上都可以省略）

因此，将原始指针转换为切片时需要考虑两件事：

您需要知道数组的确切长度才能从中创建切片;如果您知道，可以使用slice::from_raw_parts()或slice::from_raw_parts_mut();
如果要转换嵌套数组，则需要重建间接的每一层，因为指针的大小与切片大小不同。

当然，您必须跟踪谁是缓冲区的所有者以及何时将其释放，否则您可以轻松获得指向不再存在的缓冲区的切片。毕竟这是unsafe。

Answer 2

由于您的数组似乎是一个指向48000 f32数组的指针数组，因此您只需使用固定大小的数组（[T; N]）而不是切片（[T]）：

fn func() -> *mut *mut f32 { unimplemented!() }

fn main() {
    let buffer = func();
    let buffer: &mut [&mut [f32; 48000]; 2] = unsafe { std::mem::transmute(buffer) };
    for n in 0..48000 {
        buffer[0][n] = 1.0;
        buffer[1][n] = 3.0;
    }
}

转换＆＃34; * mut * mut f32＆＃34;进入＆＃34;＆amp; [＆amp; [f32]]＆＃34;

2 个答案: