Rust Programmierung für Einsteiger: Ownership-Schulung

Erste Schritte mit Rust

• Was Rust auszeichnet: Speichersicherheit ohne Garbage Collector
• Installation unter Windows mit rustup und den MSVC-Build-Tools
• Installation unter Linux und macOS mit rustup, Toolchains aktuell halten
• Anatomie eines Rust-Programms: fn main, Makros wie println!, Semikolons
• Kommentare und Dokumentationskommentare mit ///, Doku erzeugen mit cargo doc
• Programme erstellen mit Cargo: cargo new, build, run und check
• Editionen verstehen: die Angabe edition = "2024" in Cargo.toml
• rust-analyzer im Editor einrichten: Typanzeige, Inline-Fehler, Refactorings

Primitive und zusammengesetzte Datentypen

• Variablen deklarieren mit let und mut, Konstanten mit const
• Integer-Typen von i8 bis i128, usize und Verhalten bei Überlauf
• Fließkommatypen f32 und f64, Rundung und Vergleich
• Arithmetische Operationen und die Methoden checked_* und wrapping_*
• Ausgaben formatieren mit println!, format!, {:?} und {:#?}
• Bitweise Operationen und Bitverschiebungen
• Boolesche Werte und die Operatoren &&, || und !
• Vergleichsoperationen und die Traits PartialEq und PartialOrd
• Der Typ char: Unicode-Skalarwerte statt einzelner Bytes
• Typumwandlung mit as, From und TryFrom
• Arrays fester Länge: Deklaration, Zugriff und Grenzprüfung
• Mehrdimensionale Arrays für Tabellen und Raster
• Tupel bilden, auf Elemente zugreifen und destrukturieren

Funktionen

• Funktionen mit typisierten Parametern definieren
• Anweisungen versus Ausdrücke: Blöcke liefern Werte
• Rückgabewerte: letzter Ausdruck ohne Semikolon oder return
• Closures und die Traits Fn, FnMut und FnOnce

Programmablaufsteuerung

• Bedingte Ausführung mit if und else
• Mehrere Bedingungen mit else if – und wann match lesbarer ist
• Bedingte Zuweisung: if als Ausdruck in einer let-Anweisung
• Endlosschleifen mit loop und Wertrückgabe über break
• while-Schleifen mit Abbruchbedingung
• for-Schleifen über Bereiche wie 0..10 und über Iteratoren
• Verschachtelte Schleifen gezielt verlassen mit Labels wie 'aussen

Eigentümerschaft (Ownership)

• Geltungsbereich von Variablen und automatisches Freigeben über Drop
• Shadowing: Namen neu binden, statt Variablen veränderlich zu machen
• Stack und Heap: wo Rust welche Daten ablegt
• Der Typ String im Vergleich zum String-Slice &str
• Die drei Regeln der Eigentümerschaft
• Daten verschieben, klonen und kopieren: Clone und Copy
• Eigentum an Funktionen übertragen und wieder zurückgeben

Referenzen und Borrowing

• Referenzen ausleihen mit & statt Eigentum zu übertragen
• Veränderbare Referenzen &mut: ein Schreiber oder beliebig viele Leser
• Dangling-Referenzen und wie der Compiler sie verhindert
• Slices auf Strings, Arrays und Vektoren
• Slices als Funktionsparameter: &str statt &String, &[T] statt &Vec<T>

Standardbibliothek, Module und Crates

• Die Rust-Standardbibliothek und ihre Dokumentation auf docs.rs nutzen
• Von der Standardeingabe lesen mit std::io::stdin
• Zeichenketten in Zahlen parsen mit parse::<T>() und Fehler auswerten
• Crates von crates.io einbinden mit cargo add, Versionen in Cargo.lock
• Eigenen Code in Module gliedern: mod, pub und use
• Workspaces für Projekte aus mehreren Crates

Eingabe und Ausgabe

• Befehlszeilenargumente mit std::env::args und mit dem Crate clap
• Aus Dateien lesen mit std::fs und zeilenweise über BufReader
• In Dateien schreiben mit std::fs::write und gepuffert mit BufWriter
• Plattformunabhängige Pfade mit Path und PathBuf

Strukturen

• Strukturen definieren und Instanzen erzeugen
• Syntax der Strukturaktualisierung mit ..vorlage
• Methoden in impl-Blöcken mit &self und &mut self
• Zugehörige Funktionen wie new() als Konstruktoren
• Tupel-Strukturen und das Newtype-Muster für eigene Typen

Enums und Pattern Matching

• Enums definieren, auch mit Daten in den Varianten
• Der match-Ausdruck und die Prüfung auf Vollständigkeit
• Platzhalter _ und Bereichsmuster in match-Armen
• Methoden für Enums in impl-Blöcken
• Das Enum Option<T> als Ersatz für Null-Werte
• Option<T> auswerten mit match, map und unwrap_or
• Kurzformen if let und let … else für einzelne Muster

Fehlerbehandlung

• Nicht behebbare Fehler mit panic! und wann sie angemessen sind
• Das Enum Result<T, E> für behebbare Fehler
• Result<T, E> mit match auswerten und Fehler gezielt behandeln
• Fehler weiterreichen mit dem ?-Operator
• Eigene Fehlertypen mit thiserror, in Anwendungen anyhow

Sammlungen und Iteratoren

• Vektoren Vec<T> anlegen, erweitern und durchlaufen
• HashMap<K, V>: einfügen, abfragen und zählen mit der Entry-API
• Iterator-Adapter map, filter, enumerate und collect

Generische Typen und Traits

• Generische Struktur-Definitionen
• Generische Methoden in impl<T>-Blöcken
• Generische Funktionen mit Typparametern
• Daten auf dem Heap mit Box<T>, etwa für rekursive Typen
• Traits definieren und für eigene Typen implementieren
• Standardimplementierungen von Trait-Methoden
• Traits ableiten mit #[derive(Debug, Clone, PartialEq)]
• Trait-Grenzen für generische Parameter
• Mehrere Trait-Grenzen mit + und where-Klauseln
• Rückgabetypen mit impl Trait und Trait-Objekte mit dyn Trait

Lifetimes (Gültigkeitsdauer)

• Der Borrow-Checker und wie man seine Fehlermeldungen liest
• Syntax der Lifetime-Annotation 'a
• Mehrere Lifetime-Annotationen in einer Signatur
• Lifetime Elision: Regeln, nach denen Annotationen entfallen
• Strukturen, die Referenzen halten, mit Lifetimes annotieren
• Die statische Lebensdauer 'static und häufige Missverständnisse

Testen und Codequalität

• Unit-Tests mit #[test] und cargo test, Integrationstests im Ordner tests
• Dokumentationstests: Beispiele in ///-Kommentaren automatisch prüfen
• Code formatieren mit rustfmt und Hinweise von Clippy umsetzen

Nebenläufigkeit – erster Einstieg

• Threads starten mit std::thread::spawn und std::thread::scope
• Gemeinsamer Zustand mit Arc<Mutex<T>>, Nachrichten über Kanäle
• Send und Sync: wie der Compiler Data Races ausschließt
• Ausblick auf async/await mit Tokio für Netzwerkdienste

Rust-Projekte mit einem Coding-Agenten

• Rust-Fehlermeldungen als Arbeitsauftrag: Agent iteriert mit cargo check, bis alles baut
• Borrow-Checker-Lösungen bewerten: Referenz, Neuentwurf oder doch nur .clone()?
• Projektregeln: #![forbid(unsafe_code)], cargo clippy -- -D warnings als Pflicht
• Vom Agenten vorgeschlagene Crates mit cargo tree und cargo audit begutachten
• Vor jedem Umbau einer Rust-Funktion zuerst #[test]-Fälle vom Agenten schreiben lassen

Praxisprojekt: Auswertung von Sensordaten auf der Kommandozeile

• Messwerte aus einer CSV-Datei einlesen, parsen und mit Result validieren
• Minimum, Maximum und Mittelwert je Sensor in einer HashMap sammeln
• Kommandozeile mit clap, Tests mit cargo test, Clippy ohne Warnungen