Rust：数组长度的宏

Question

我有一个包含原始二进制数据的文件，我想把它加载到一个4字节长的u32字数组中。

可以通过在编译时包含文件的内容来执行：

let bytes = include_bytes!("audio.raw");

然后，我可以使用transmute将其转换为u32字的数组。新数组的长度显然应该是原始字节数组的1/4。

let audio = unsafe { std::mem::transmute::<[u8; 63504], [u32; 15876]>(*bytes) };
// works

正如你在上面看到的，我必须对输入和输出数组的长度进行硬编码。然而，当试图避免硬编码这些数字时，它不起作用：

let audio = unsafe { std::mem::transmute::<[u8; bytes.len()], [u32; bytes.len()/4]>(*bytes) };
// error: non-constant value

似乎。len（）在运行时被调用，由于在Rust中无法分配动态数组，因此会产生错误。然而，理论上，应该有一种方法来计算编译阶段所需的长度，因为字节数组的长度是固定的。所以我的问题是：是否有一个宏返回静态数组的长度？

（我非常清楚向量可以进行动态分配，我的问题是关于固定大小的数组。）

示例代码（include_bytes替换为硬编码数组）：

fn main() {
    // let bytes = include_bytes!("audio.raw");
    let bytes = [1, 0, 0, 0, 2, 0, 0, 0];

    // works:
    let audio = unsafe { std::mem::transmute::<[u8; 8], [u32; 2]>(bytes) };

    // error:
    let audio = unsafe { std::mem::transmute::<[u8; bytes.len()], [u32; bytes.len() / 4]>(bytes) };

    println!("{}", audio[1]);
}

Answer 1

array实现Deref

为了获得一个表示数组长度的常量值，trait助手可能会满足您的需要。

稳定的：

trait ArrayLen {
    const SIZE: usize;
}

macro_rules! impl_array(
    ($($size:expr),+) => {
        $(
            impl<'a, T> ArrayLen for &'a [T; $size] {
                const SIZE: usize = $size;
            }
        )+
    }
);

impl_array!(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 20, 24, 32, 36,
            0x40, 0x80, 0x100, 0x200, 0x400, 0x800, 0x1000, 0x2000, 0x4000, 0x8000,
            0x10000, 0x20000, 0x40000, 0x80000, 0x100000);

fn print<T>(_: T)
where
    T: ArrayLen
{
    println!("{}", T::SIZE);
}

fn main() {
    let bytes = include_bytes!("four_bytes_file.something");
    // The length of `bytes` must match one of the implementations
    print(bytes);
}

每晚：

#![feature(const_generics)]

trait ArrayLen {
    const SIZE: usize;
}

impl<'a, T, const N: usize> ArrayLen for &'a [T; N] {
    const SIZE: usize = N;
}

fn print<T>(_: T)
where
    T: ArrayLen
{
    println!("{}", T::SIZE);
}

fn main() {
    let bytes = include_bytes!("any_file.something");
    print(bytes);
}

然而，[T；CONST_PARAMETER/4]目前是不可能的，但事情可能会随着https://github.com/rust-lang/rust/issues/60471.而改变

Answer 2

通常，不复制就无法将u8的数组转换为u32的数组。

此转换仅在以下条件下有效：

>

对齐。数组需要对齐以容纳u32，这通常意味着它需要从四的倍数开始。对于使用创建的字节数组，请包含_字节！（）macro，无法保证合适的对齐方式。这可以用以下代码来说明（playgorund：

let bytes: [u8; 5] = [1, 2, 3, 4, 5];
dbg!(bytes.as_ptr().align_offset(std::mem::align_of::<u32>()));

当我尝试在操场上运行它时，结果是1，这意味着字节数组没有对齐以保存u32，但不能保证结果。

Endianness。数组中的字节必须表示与目标体系结构endianness匹配的endianness中的32位整数。如果从文件加载的数据是little endian格式的，则任何将数据解释为32位整数而不进行任何转换的代码都只能在little endian平台上工作。

长度。字节数组的长度需要是u32大小的倍数，即4的倍数。

如果满足这些条件，理论上可以使用以下代码将字节数组转换为u32的切片：

let audio = unsafe {
    let ptr = bytes.as_ptr() as *const u32;
    let factor = std::mem::size_of::<u32>() / std::mem::size_of::<u8>();
    let len = bytes.len() / factor;
    if ptr.align_offset(std::mem::align_of::<u32>()) == 0
        && bytes.len() % factor == 0
        && cfg!(target_endian = "little")
    {
        std::slice::from_raw_parts(ptr, len)
    } else {
        // Perform proper conversion.
    }
};

然而，这似乎不值得费心——无论如何，您都需要实现真正的转换代码。

我的建议是使用实际的音频文件格式，并使用库加载它-这将为您节省各种麻烦。