Início / coding / Perguntas / 77621474
Accepted
BallpointBen
Asked: 2023-12-08 00:06:23 +0800 CST

Atribuição de correspondência de padrão de ferrugem: obtenha inicial `[T; k]` de `[T; n]`

  • 772

Em Rust, é possível usar correspondência de padrões para construir [T; k]a partir dos primeiros kelementos de a [T; n]? Eu gostaria de evitar isso:

// k = 3 here
let [c1, c2, c3, ..] = my_array;
let front = [c1, c2, c3];

e em vez disso faça algo assim (sintaxe inventada):

let front: [T; 3];
[..front, ..] = my_array;
// or...
let [..front: [T; 3], ..] = my_array;
// or...
let [front @ [_; 3], ..] = my_array;

Algo assim é possível?

arrays

1 respostas

  1. Best Answer

    Se Tfor uma cópia, você pode fazer isso facilmente:

    let front: [T; 3] = my_array[..3].try_into().unwrap();

    Se Tnão for, Copymas tiver um preço barato Clone, você também pode fazer:

    let front: [T; 3] = <&[T; 3]>::try_from(&my_array[..3]).unwrap().clone();

    Se não for (a clonagem é cara ou Tnão é Clone), você pode fazer isso com uma alocação:

    let front = my_array.into_iter().take(3).collect::<Vec<T>>();
let front: [T; 3] = front.try_into().unwrap();

    Se uma alocação não for aceitável, mas você estiver trabalhando todas as noites, poderá usar Iterator::next_chunk():

    #![feature(iter_next_chunk)]

let front: [T; 3] = my_array.into_iter().next_chunk().unwrap();

    E finalmente, se nada for suficiente para você, você pode fazer isso usando código inseguro (mas este deve ser o último recurso):

    use std::mem::ManuallyDrop;

pub fn front<T, const N: usize, const M: usize>(arr: [T; N]) -> [T; M] {
    assert!(M <= N);
    let mut arr = ManuallyDrop::new(arr);
    unsafe {
        let result: [T; M] = arr.as_ptr().cast::<[T; M]>().read();
        let rest = arr.as_mut_ptr().add(M);
        let rest_len = N - M;
        let rest = std::ptr::slice_from_raw_parts_mut(rest, rest_len);
        rest.drop_in_place();
        result
    }
}
    • 2

relate perguntas