Die Rust-Standardbibliothek: Ein vollständiger Überblick über die wichtigsten Module und Funktionen

Die Rust-Standardbibliothek: Ein vollständiger Überblick

Die Rust-Standardbibliothek (std) ist eine Sammlung grundlegender Module, die dem Entwickler alles Nötige zur Erstellung zuverlässiger, schneller und sicherer Anwendungen bieten. Im Gegensatz zu vielen anderen Sprachen legt Rust besonderen Wert auf Speichersicherheit und Parallelität ohne Garbage Collector. In diesem Artikel werden wir die Schlüsselkomponenten von std mit Codebeispielen im Detail analysieren.

1. Wichtige Module der Standardbibliothek

Die Bibliothek ist in mehrere logische Gruppen unterteilt. Betrachten wir die wichtigsten davon.

1.1. Das Modul std::collections

Enthält Datenstrukturen zum Speichern und Verwalten von Sammlungen von Elementen. Die beliebtesten:

• Vec<T> — ein dynamisches Array (Analog zu ArrayList in Java).
• HashMap<K, V> — eine Hashtabelle zum Speichern von Schlüssel-Wert-Paaren.
• HashSet<T> — eine Menge eindeutiger Werte.
• BTreeMap und BTreeSet — sortierte Sammlungen auf Basis eines Rot-Schwarz-Baums.

use std::collections::HashMap;

fn main() {    let mut scores = HashMap::new();    scores.insert(String::from("Alice"), 100);    scores.insert(String::from("Bob"), 90);

    for (name, score) in &scores {        println!("{}: {}", name, score);    }}

1.2. Das Modul std::io

Zuständig für Ein-/Ausgabe: Tastatureingabe, Dateiarbeit, gepufferte Ein-/Ausgabe. Schlüssel-Traits: Read und Write.

use std::io::{self, BufRead};

fn main() -> io::Result<()> {    let stdin = io::stdin();    for line in stdin.lock().lines() {        println!("Sie haben eingegeben: {}", line?);    }    Ok(())}

1.3. Das Modul std::thread

Ermöglicht das Erstellen und Verwalten von Ausführungsthreads. Rust garantiert die Datensicherheit zwischen Threads durch das Ownership-System und die Traits Send und Sync.

use std::thread;

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

    for i in 1..5 {        println!("Hauptthread: {}", i);    }

    handle.join().unwrap();}

2. Arbeiten mit Strings und Text

In Rust gibt es zwei String-Typen:

• String — ein veränderbarer, besitzender String (auf dem Heap).
• &str — ein unveränderlicher String-Slice (Referenz auf eine UTF-8-Sequenz).

fn main() {    let mut hello = String::from("Hallo, ");    hello.push_str("Welt!");    println!("{}", hello); // Ausgabe: Hallo, Welt!

    let slice: &str = &hello[0..6];    println!("Slice: {}", slice); // Ausgabe: Hallo}

3. Fehlerbehandlung

Anstelle von Ausnahmen verwendet Rust zwei Aufzählungen:

• Option<T> — für Fälle, in denen ein Wert fehlen kann (Some oder None).
• Result<T, E> — für Operationen, die mit einem Fehler enden können (Ok oder Err).

use std::fs::File;use std::io::Read;

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

fn main() {    match read_file("test.txt") {        Ok(content) => println!("Inhalt: {}", content),        Err(e) => eprintln!("Fehler: {}", e),    }}

4. Iteratoren und Closures

Iteratoren in Rust sind lazy und leistungsstark. Sie ermöglichen die Verarbeitung von Datensequenzen ohne explizite Schleifen.

fn main() {    let numbers = vec![1,