Jaki jest najlepszy sposób na konwersję [[T; 4]; 3] w [T; 12]?

Question

Rozumiem, że [[T; 4]; 3] i [T; 12] mają taki sam układ w pamięci. Jaki jest najlepszy sposób na konwersję wartości między tymi typami? Czy mogę zamienić odniesienie na jedno na odniesienie do drugiego? Czy mogę uniknąć kopiowania wszystkich elementów? Czy potrzebuję unsafe?

Answer 1

Tak, możesz zamienić odniesienie na [[T; 4]; 3] na odniesienie do [T; 12], ale tylko z niebezpiecznym kodem, używając mem::transmute. Najlepiej jest zawrzeć to w funkcji, aby wynikowy odnośnik miał przypisany odpowiedni czas życia, ponieważ w przeciwnym razie transmute umożliwiłoby uzyskanie odniesienia o dłuższym czasie życia niż powinno mieć odniesienie.

fn convert<'a>(a: &'a [[u8; 4]; 3]) -> &'a [u8; 12] { 
    unsafe { std::mem::transmute(a) } 
} 

ten może zostać skrócony dzięki zasadom życia elizja:

fn convert(a: &[[u8; 4]; 3]) -> &[u8; 12] { 
    unsafe { std::mem::transmute(a) } 
} 

Choć gdy ma do czynienia z niebezpiecznym kodem, chciałbym zrozumieć, jeśli preferowane bardziej wyraźny wersję!

Answer 2

Nota prawna: Nie jestem naprawdę świetny w sprawie niskiego poziomu rdzy Rusta, ale nie wiem, co jest uważane za "dobrą praktykę" w rdzy niskiego poziomu. Porady tutaj podane mogą nie być dobrymi pomysłami. Wrzucam je tutaj, ponieważ ... no cóż, działają.

You could transmute them. Problem polega na tym, że będzie to kopia, dokumentacja mówi, że jest to odpowiednik połączenia memcpy. To nie jest to, czego chciał, ale tutaj jest to w każdym razie:

fn main() { 
    let a: [[u8; 4]; 3] = [[1, 2, 3, 4], [1, 2, 3, 4], [1, 2, 3, 4]]; 
    let b: [u8; 12] = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]; 

    println!("a: {:?}", a); 
    println!("b: {:?}", b); 

    let c = unsafe { std::mem::transmute::<[[u8; 4]; 3], [u8; 12]>(a) }; 

    println!("c: {:?}", c); 
} 

Twój innych opcji is to work with a raw pointer:

fn main() { 
    let a: [[u8; 4]; 3] = [[1, 2, 3, 4], [1, 2, 3, 4], [1, 2, 3, 4]]; 
    let b: [u8; 12] = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]; 

    println!("a: {:?}", a); 
    println!("b: {:?}", b); 

    let c = &a as *const _ as *const [u8; 12]; 
    // Or it can be this: let c = &mut a as *mut [[u8; 4]; 3]; 

    for i in 0..12 { 
     let p = c as *const u8; 
     let v = unsafe { *p.offset(i) }; 
     println!("{}", v); 
    } 
} 

który nie jest szczególnie wielki albo.

Wskaźnik może być również wskaźnikiem lub zmienny wskaźnik do tego samego typu (od &mut T mogą być oddane do *mut T), a powyższy kod działa dokładnie tak samo (z a oznaczone zmienny):

let c = &mut a as *mut [[u8; 4]; 3]; 

Zastanawiam się, czy jest to jednak problem XY. Być może sposób, w jaki pracujesz z danymi, może zostać zmieniony, aby tego nie wymagać?