Umwandlung von Zahl-primitive (i32, f64, etc) - byte-Darstellungen

Ich Schreibe eine Bibliothek, kodiert/dekodiert die Daten zu/von einem binären format. Teil des formats ist zahlen, ich bin mit Rost native primitive Typen für die (wie i8, i64, f32 etc.).

Gibt es eine einfache, integrierte Möglichkeit zur Konvertierung von Datentypen in/aus Binär, d.h. konvertieren f64/f32/i64/etc. in einem Vec<u8>? Ebenso ist es ein Weg, um zu konvertieren 4 u8s (in einem Vec<u8> sagen) in eine f32?

  • Bitte, können Sie markieren Sie den Nikolaus Rishel ' s Antwort als angenommen? Das ist die kanonische Antwort nun, und die ältesten mit transmute Beispiele können irreführend sein.
InformationsquelleAutor Rory | 2015-04-04
  1. 21

    Leider gibt es keine sichere integrierte Unterstützung für das Lesen/schreiben von primitiven aus/ein byte-array in Rust im moment. Es gibt mehrere community-Bibliotheken für, die, jedoch, byteorder, die am meisten verwendet man:

    extern crate byteorder;

use byteorder::{LittleEndian, WriteBytesExt};
use std::mem;

fn main() {
    let i: i64 = 12345;
    let mut bs = [0u8; mem::size_of::<i64>()];
    bs.as_mut()
        .write_i64::<LittleEndian>(i)
        .expect("Unable to write");

    for i in &bs {
        println!("{:X}", i);
    }
}

    Natürlich, Sie können immer wirken raw-Pointer. Zum Beispiel, können Sie *const i64 in *const i8 und dann konvertieren Sie Sie in ein geeignetes byte-slice &[u8]. Dies ist jedoch leicht zu bekommen, falsch, unsafe -und Plattform-abhängige aufgrund endiannness, so sollte es nur verwendet werden, als eine Letzte resort:

    use std::{mem, slice};

fn main() {
    let i: i64 = 12345;
    let ip: *const i64 = &i;
    let bp: *const u8 = ip as *const _;
    let bs: &[u8] = unsafe { slice::from_raw_parts(bp, mem::size_of::<i64>()) };

    for i in bs {
        println!("{:X}", i);
    }
}
    • Mit std::slice::from_raw_parts ist weniger code und auch als stabil gekennzeichnet. Immer noch unsicher, aus den gleichen Gründen, obwohl!
    • byteorder löst es genau. Wenn ich sagte, "Baujahr", ich sollte angegeben haben, dass etwas aus der Kiste.io würde ausreichen.
    InformationsquelleAutor Vladimir Matveev
  2. 17

    Als der Rost 1.32 können Sie {to,from}_{ne,le,be}_bytes für Integrale Typen.

    let begin = 1234_i32;
let bytes = begin.to_ne_bytes();
let and_back = i32::from_ne_bytes(bytes);

    Für floating-point haben Sie immer noch angewiesen auf Methoden vor.

    InformationsquelleAutor Nicholas Rishel
  3. 15

    std::mem::transmute können verwendet werden, obwohl es unsafe:

    fn main() {
    let var1 = 12345678_i64;
    let raw_bytes: [i8; 8] = unsafe { std::mem::transmute(var1) };
    for byte in &raw_bytes {
        println!("{}", byte);
    }
}

    Hinweis: Sie Bitte sicher, dass die Größe der beiden Variablen genau gleich.

    • Für die richtige Größe kann man mit std::mem::size_of::<i64>() statt 8 im array
    • Paar Dinge: raw_bytes sollte [u8; 8] (oder mem::size_of wie vorgeschlagen) und wenn die Größen nicht übereinstimmen, transmute wird nicht funktionieren: "kann nicht umwandeln zwischen verschiedenen Arten in verschiedenen Größen, abhängig oder-sized types" so ist es "irgendwie sicher".
    InformationsquelleAutor F001
  4. 6

    Gebäude aus der Nicholas Rishel ' s Antwort.

    Rost 1.32 hat: {an,aus}_{ne,le,be}_bytes, to_bits, und from_bits.

    Konvertieren einer Ganzzahl in bytes dann wieder:

    let x = 65535_i32;
let x_bytes = x.to_ne_bytes();                  //x_bytes = [255, 255, 0, 0]
let original_x = i32::from_ne_bytes(x_bytes);   //original_x = 65535 = x

    Umwandlung einer float-bytes dann wieder:

    let y = 255.255_f64;
let y_bytes = y.to_bits().to_ne_bytes();
let original_y = f64::from_bits(u64::from_ne_bytes(y_bytes)); //original_y = 255.255 = y

    Entsprechend der Rost Dokumentation from_bits können portabilitätsprobleme.

    InformationsquelleAutor Michael Crapse
  5. 1

    Wenn Ihr Ziel ist, drucken Sie die bytes oder haben Sie in einer str Darstellung, verwenden Sie einfach die :b notation in einem format Klammer

    fn main() {
    println!("This is the binary of int {:b}", 4 as i32);
}

    Diese Drucke

    This is the binary of int 100

    InformationsquelleAutor Josh Weinstein
Schreibe einen Kommentar