Rust Standardbibliothek: Vollständiger Überblick für Entwickler

Rust Standardbibliothek: Vollständiger Überblick

Die Rust Standardbibliothek (std) ist das Fundament, auf dem jede Anwendung in dieser Sprache aufbaut. Sie bietet eine Reihe zuverlässiger, effizienter und sicherer Werkzeuge zur Lösung typischer Aufgaben, von der Arbeit mit Sammlungen bis zur speichernahen Verwaltung. Im Gegensatz zu vielen anderen Sprachen ist die Rust Standardbibliothek so konzipiert, dass sie die Abhängigkeit von externen Crates für grundlegende Operationen minimiert, während sie eine Leistung nahe an C/C++ beibehält.

Hauptmodule der Standardbibliothek

Die Standardbibliothek ist in logische Module organisiert. Betrachten wir die wichtigsten davon:

• std::collections — Datenstrukturen: Vec, HashMap, HashSet, BTreeMap, LinkedList und andere.
• std::io — Ein-/Ausgabe: Dateien lesen/schreiben, Arbeit mit Strömen, Pufferung.
• std::fs — Dateisystem: Erstellen, Löschen, Kopieren von Dateien und Verzeichnissen.
• std::thread — Multithreading: Erstellen von Threads, Synchronisation über Mutex, Arc.
• std::sync — Synchronisationsprimitive: Kanäle (mpsc), Barrieren, Semaphore.
• std::net — Netzwerkprogrammierung: TCP/UDP-Sockets, Adressen.
• std::time — Zeitmessung: Messungen, Timer, Dauern.
• std::mem — Speicherverwaltung: Typgrößen, Ausrichtung, swap, replace.

Sammlungen: Von Vec bis HashMap

Sammlungen in Rust sind nicht nur Container. Sie implementieren eine umfangreiche API und garantieren Speichersicherheit zur Kompilierzeit. Die beliebteste Sammlung ist Vec<T> — ein dynamisches Array.

fn main() {    let mut numbers: Vec<i32> = vec![1, 2, 3, 4];    numbers.push(5);        // Iteration mit Änderung    for num in &mut numbers {        *num *= 2;    }        // Filterung    let evens: Vec<&i32> = numbers.iter()        .filter(|&&x| x % 2 == 0)        .collect();        println!("{:?}", evens); // [2, 4, 6, 8, 10]}

HashMap — assoziatives Array mit Hashing. Wichtig zu beachten: Standardmäßig wird ein kryptografisch sicherer Hash-Algorithmus (SipHash) verwendet, der Angriffe wie HashDoS verhindert.

use std::collections::HashMap;

fn main() {    let mut scores = HashMap::new();    scores.insert(String::from("Alice"), 100);    scores.insert(String::from("Bob"), 85);        // Sicheres Abrufen eines Wertes    match scores.get(&String::from("Alice")) {        Some(score) => println!("Score: {}", score),        None => println!("Nicht gefunden"),    }        // Durchlauf mit Iterator    for (name, score) in &scores {        println!("{}: {}", name, score);    }}

Arbeit mit Ein-/Ausgabe und Dateien

Das Modul std::io bietet sowohl hochrangige als auch niedrigrangige Mittel zur Arbeit mit Datenströmen. Besondere Beachtung verdienen die Traits Read und Write.

use std::fs::File;use std::io::{self, Read, Write};

fn read_file(path: &str) -> io::Result<String> {    let mut file = File::open(path)?;    let mut contents = String::new();    file.read_to_string(&mut contents)?;    Ok(contents)}

fn write_file(path: &str, data: &str) -> io::Result<()> {    let mut file = File::create(path)?;    file.write_all(data.as_bytes())?;    Ok(())}

fn main() -> io::Result<()> {    write_file("example.txt", "Hallo, Rust