Rust Standardbibliothek: vollständiger Überblick

Rust Standardbibliothek: vollständiger Überblick

Die Rust Standardbibliothek (std) ist der Kern des Sprachökosystems und bietet Entwicklern leistungsstarke und sichere Werkzeuge zur Erstellung leistungsstarker Anwendungen. Im Gegensatz zu vielen anderen Sprachen legt Rust besonderen Wert auf Speichersicherheit und Nullkostenabstraktionen, was std nicht nur zu einer Sammlung von Hilfsprogrammen, sondern zu einer Grundlage für das Schreiben zuverlässigen Codes macht. In diesem Artikel werden wir die wichtigsten Module der Standardbibliothek, ihre Funktionen im Detail besprechen und praktische Beispiele geben.

Wichtige Module der Standardbibliothek

Die Rust Standardbibliothek umfasst viele Module, die nahezu alle Aspekte der Entwicklung abdecken. Betrachten wir die wichtigsten davon:

• std::collections — Datenstrukturen (HashMap, Vec, BTreeMap, HashSet und andere)
• std::io — Ein-/Ausgabe (Dateien lesen/schreiben, Konsolenarbeit)
• std::fs — Dateisystemoperationen
• std::thread — Multithreading
• std::sync — Thread-Synchronisation (Mutex, Arc, Barrier)
• std::net — Netzwerkprogrammierung (TCP, UDP)
• std::path — Arbeit mit Dateisystempfaden
• std::error — Fehlerbehandlung

Arbeit mit Collections (std::collections)

Das Modul std::collections bietet effiziente Datenstrukturen. Die beliebteste ist Vec<T> (dynamisches Array). Häufig verwendet werden auch HashMap<K, V> zum Speichern von Schlüssel-Wert-Paaren und HashSet<T> für eindeutige Elemente.

use std::collections::HashMap;

fn main() {    let mut scores = HashMap::new();    scores.insert(String::from("Blue"), 10);    scores.insert(String::from("Yellow"), 50);

    // Zugriff über Schlüssel    match scores.get(&"Blue".to_string()) {        Some(score) => println!("Score: {}", score),        None => println!("Kein Score gefunden"),    }}

Ein-/Ausgabe und Dateiarbeit (std::io und std::fs)

Die Module std::io und std::fs ermöglichen das Lesen und Schreiben von Dateien sowie die Arbeit mit Konsolenein-/ausgabe. Rust gewährleistet dank des Ownership-Systems eine sichere Dateiarbeit.

use std::fs::File;use std::io::{BufRead, BufReader, Write};

fn main() -> std::io::Result<()> {    // In Datei schreiben    let mut file = File::create("example.txt")?;    file.write_all(b"Hallo, Rust!")?;

    // Datei zeilenweise lesen    let file = File::open("example.txt")?;    let reader = BufReader::new(file);    for line in reader.lines() {        println!("{}", line?);    }    Ok(())}

Multithreading (std::thread)

Rust bietet ein sicheres Multithreading-Modell über das Modul std::thread. Der Compiler verhindert Datenrennen bereits zur Compile-Zeit dank der Ownership- und Borrowing-Regeln.

use std::thread;use std::time::Duration;

fn main() {    let handle = thread::spawn(|| {        for i in 1..5 {            println!("Thread: {}", i);            thread::sleep(Duration::from_millis(100));        }    });

    for i in 1..3 {        println!("Hauptthread: {}", i);        thread::sleep(Duration::from_millis(50));    }

    handle.join().unwrap();}

Synchronisation (std::sync)

Für den sicheren Datenaustausch zwischen Threads werden Primitive aus std::sync verwendet: Mutex (gegenseitiger Ausschluss), Arc (atomarer Referenzzähler) und Barrier (Synchronisationsbarriere).

use std::sync::{Arc, Mutex};use std::thread;

fn main() {    let counter = Arc::new(Mutex::new(0));    let mut handles = vec![];

    for _ in 0..10 {\