Kapitel 03: Fundamente: Variablen & Typen (Sicht für Anfänger)

In diesem Kapitel lernen wir, wie der Computer Informationen im Gedächtnis behält, warum Rust dabei sehr vorsichtig vorgeht und welche Arten von Schachteln es für deine Daten gibt.

1. Lernziele

Du wirst in diesem Abschnitt:

• Verstehen, was eine Variable im Arbeitsspeicher (RAM) wirklich ist.
• Erkennen, warum Rust standardmäßig Sekundenkleber auf alle Variablen schmiert (Unveränderlichkeit).
• Lernen, wie du mit Shadowing Variablen sicher überschreibst.
• Die verschiedenen Schachtelgrößen (Datentypen) für Zahlen, Kommazahlen, Wahrheitswerte und Emojis kennenlernen.
• Erfahren, warum das Fehlen von null dein Programm vor schweren Abstürzen rettet.

2. Variablen: Die Aufkleber im Arbeitsspeicher

Stell dir den Arbeitsspeicher (RAM) deines Computers wie ein gigantisches Postgebäude mit Milliarden durchnummerierter Postfächer vor. Jedes Fach kann eine kleine Information aufnehmen. Ohne Programmiersprache müsstest du dir merken: “Meine Zahl liegt in Fach Nr. 832.194.281.” Das ist unmöglich.

Eine Variable ist einfach ein Aufkleber mit einem lesbaren Namen (z. B. alter), den wir auf das Postfach kleben.

#![allow(unused)]
fn main() {
let alter = 30;
}

Ab jetzt weiß der Computer: Wenn wir alter sagen, meinen wir den Inhalt in diesem Postfach.

Sekundenkleber auf den Variablen (Unveränderlichkeit)

In vielen Programmiersprachen darfst du den Wert einer Variablen jederzeit ändern. Rust ist hier anders und standardmäßig sehr misstrauisch. Wenn du eine Variable erstellst, klebt Rust sie sofort fest: Sie ist unveränderlich (immutable).

fn main() {
    let x = 5;
    x = 6; // FEHLER! Der Compiler verbietet das!
}

Warum macht Rust das? Wenn Daten sich nicht heimlich ändern können, ist dein Programm viel sicherer und leichter zu verstehen – besonders wenn später viele Aufgaben gleichzeitig erledigt werden müssen.

Das Wort mut (Die veränderbare Schüssel)

Wenn du eine Variable brauchst, die sich verändern darf (z. B. einen Punktestand in einem Spiel), musst du das explizit ankündigen. Dafür nutzt du das Wort mut (kurz für mutable, veränderbar):

fn main() {
    let mut punkte = 0;
    punkte = punkte + 10; // Das funktioniert wunderbar!
}

3. Shadowing: Die alte Schachtel wegwerfen

Rust hat einen sehr praktischen Trick namens Shadowing (Variablenüberdeckung). Du darfst denselben Variablennamen mehrmals mit dem Wort let definieren:

fn main() {
    let text = "42";
    let text: i32 = text.parse().unwrap(); // Der Typ ändert sich von Text zu Zahl!
}

Was passiert hier? Im Gegensatz zu mut ändern wir nicht den Inhalt der Schüssel. Wir werfen die alte Schachtel einfach komplett in den Müll und stellen eine brandneue Schachtel mit demselben Namen ins Regal. Das ist genial, wenn du Daten transformierst und keine unschönen Namen wie text_eingabe und zahl_eingabe erfinden willst.

4. Die primitiven Datentypen (Die Schachtelgrößen)

Der Computer muss genau wissen, wie groß das Postfach sein muss. Rust bietet uns folgende Standardformen an:

Ganzzahlen (Integers)

• Mit Vorzeichen (können negativ sein): i8, i16, i32 (Standard), i64, i128. (Die Zahl gibt die Bit-Größe an).
• Ohne Vorzeichen (nur positiv oder Null): u8 (geht von 0 bis 255), u16, u32, u64, u128.
• usize / isize: Die Größe passt sich automatisch an deinen Prozessor an (bei 64-Bit-PCs sind das 8 Byte). Wird meistens für Listen-Indizes verwendet.

Fließkommazahlen (Dezimalzahlen)

• f32 und f64 (Standard). f64 hat eine extrem hohe Genauigkeit (doppelte Genauigkeit), um Rundungsfehler zu minimieren.

Wahrheitswerte (bool)

• Kann genau zwei Zustände annehmen: true (wahr) oder false (falsch).

Schriftzeichen (char)

• Speichert genau ein Zeichen in einfachen Anführungszeichen (z. B. 'A').
• In Rust belegt ein char immer 4 Byte, weil er jedes Zeichen der Welt (Unicode) inklusive Emojis ('🦀') speichern kann!

Important

Rust konvertiert Typen niemals heimlich! Du kannst eine u8-Zahl nicht mit einer i32-Zahl addieren. Du musst den Konvertierungs-Befehl as nutzen:

#![allow(unused)]
fn main() {
let a: u8 = 10;
let b: i32 = a as i32 + 5;
}

5. Kein null – Der sichere Karton Option<T>

In vielen Sprachen gibt es den Wert null (bedeutet: “Kein Wert vorhanden”). Wenn man darauf zugreift, stürzt das Programm ab. Rust hat kein null. Wenn ein Wert fehlen darf, verpackt Rust ihn in eine Schachtel namens Option:

#![allow(unused)]
fn main() {
// Ein Option-Karton kann zwei Zustände haben:
let ein_wert = Some(42); // Der Karton ist voll und enthält die 42
let kein_wert = None;     // Der Karton ist leer
}

Der Compiler zwingt dich dazu, den Karton erst vorsichtig zu öffnen, bevor du an den Wert herankommst. Dadurch sind Abstürze durch leere Variablen unmöglich!

6. Key Takeaways

• Variablen sind standardmäßig unveränderlich. mut erlaubt Änderungen.
• Shadowing erstellt eine komplett neue Variable mit gleichem Namen.
• Ein char belegt 4 Byte und kann Unicode-Symbole und Emojis speichern.
• Es gibt kein null. Nutze Option<T> für eventuell fehlende Werte.