Hat Rust eine Möglichkeit, mehrere Bytes in eine Zahl umzuwandeln?

Question

Und eine Zahl in ein Byte-Array konvertieren?

Ich möchte vermeiden, transmute zu verwenden, aber es ist am wichtigsten, maximale Leistung zu erreichen.

Answer 1

Es gibt , um von einer Zeichenfolge zu konvertieren (Sie können die Basis und T kann ein beliebiger ganzzahliger Typ sein).

Um eine ganze Zahl in eine String konvertieren Sie format! verwenden können:

format!("{:x}", 42) == "2a" 
format!("{:X}", 42) == "2A" 

---

EDIT:

Wenn Sie zwischen u32 und [u8; 4] (zum Beispiel) konvertieren möchten Sie transmute verwenden können, Dafür ist es da.

Beachten Sie auch, dass Rust hat to_be und to_le Funktionen mit Endianess beschäftigen:

unsafe { std::mem::transmute::<u32, [u8; 4]>(42u32.to_le()) } == [42, 0, 0, 0] 
unsafe { std::mem::transmute::<u32, [u8; 4]>(42u32.to_be()) } == [0, 0, 0, 42] 
unsafe { std::mem::transmute::<[u8; 4], u32>([0, 0, 0, 42]) }.to_le() == 0x2a000000 
unsafe { std::mem::transmute::<[u8; 4], u32>([0, 0, 0, 42]) }.to_be() == 0x0000002a 

Answer 2

A u32 4 Bytes sein, Sie kann Lage sein std::mem::transmute zu verwenden, um eine [u8; 4] als eine u32 jedoch zu interpretieren:

• passen von Ausrichtung
• passen sie von endianness

A keine Abhängigkeit Lösung einfach ist die Mathematik zu führen, folgende in Rob Pike's steps:

fn as_u32_be(array: &[u8; 4]) -> u32 { 
    ((array[0] as u32) << 24) + 
    ((array[1] as u32) << 16) + 
    ((array[2] as u32) << 8) + 
    ((array[3] as u32) << 0) 
} 

fn as_u32_le(array: &[u8; 4]) -> u32 { 
    ((array[0] as u32) << 0) + 
    ((array[1] as u32) << 8) + 
    ((array[2] as u32) << 16) + 
    ((array[3] as u32) << 24) 
} 

Es kompiliert unten einigermaßen effizienten Code.

Wenn Abhängigkeiten eine Option sind, ist die Verwendung der byteorder Kiste einfach.