Datentypen in Rust

Jeder Wert in Rust hat einen Typ. Der Typ sagt dem Compiler, um welche Art von Daten es sich handelt: eine ganze Zahl, eine Kommazahl, Text, wahr/falsch und so weiter. Weil Rust den Typ kennt, kann es deinen Code auf Fehler prüfen, bevor er läuft.

Wie du bei den Variablen gesehen hast, kann Rust den Typ meistens selbst erkennen (Typinferenz). Trotzdem hilft es, die wichtigsten Typen beim Namen zu kennen. Sie tauchen nämlich in Fehlermeldungen und Funktionssignaturen auf.

Ganzzahlen (Integer)

Ganzzahlen sind Zahlen ohne Komma, zum Beispiel 42 oder -7. Rust hat mehrere Ganzzahltypen. Sie unterscheiden sich in ihrer Größe und darin, ob sie negative Zahlen erlauben:

Typ	Mit Vorzeichen?	Typische Verwendung
i32	Ja (kann negativ sein)	Der Standard – nimm ihn, solange du keinen Grund für etwas anderes hast
u32	Nein (ab 0)	Anzahlen, Größen, alles, was nicht negativ sein kann
i64 / u64	Ja / Nein	Sehr große Zahlen
usize	Nein	Indizes in Collections

fn main() {
    let temperature = -5;      // standardmäßig i32
    let count: u32 = 100;      // ausdrücklich ohne Vorzeichen
    println!("{temperature} Grad, Anzahl ist {count}");
}

Ausgabe:

-5 Grad, Anzahl ist 100

▶ Selbst ausprobieren

Hinweis

„Mit Vorzeichen“ (signed) heißt, die Zahl kann negativ sein. „Ohne Vorzeichen“ (unsigned, die u-Typen) heißt: nur null oder positiv. Wenn du unsicher bist, ist i32 eine sichere Wahl.

Gleitkommazahlen (Kommazahlen)

Für Zahlen mit Nachkommastellen nimmst du Gleitkommatypen. Davon gibt es zwei: f64 (der Standard, doppelte Genauigkeit) und f32.

fn main() {
    let pi = 3.14159;      // standardmäßig f64
    let price: f32 = 9.99;
    println!("Pi ist {pi}, der Preis ist {price}");
}

Ausgabe:

Pi ist 3.14159, der Preis ist 9.99

▶ Selbst ausprobieren

Bleib bei f64, außer du brauchst ausdrücklich das kleinere f32. f64 ist genauer und auf moderner Hardware genauso schnell.

Achtung: In Rust-Code steht immer ein Punkt als Dezimaltrennzeichen (3.14), nicht ein Komma wie im Deutschen.

Booleans

Ein Boolean (bool) ist der einfachste Typ: Er ist entweder true (wahr) oder false (falsch). Du wirst ihn ständig in if-Anweisungen und Bedingungen brauchen.

fn main() {
    let is_logged_in = true;
    let has_permission: bool = false;
    println!("angemeldet: {is_logged_in}, Berechtigung: {has_permission}");
}

Ausgabe:

angemeldet: true, Berechtigung: false

▶ Selbst ausprobieren

Zeichen (char)

Ein char enthält ein einzelnes Zeichen und wird in einfachen Anführungszeichen ' ' geschrieben. Ein char in Rust kann jeder einzelne Unicode-Skalarwert sein. Das deckt die meisten Emojis ab. Ein paar komplexe Emojis (wie Flaggen oder Emojis, die aus mehreren verbundenen Zeichen bestehen) passen aber nicht in ein einziges char.

fn main() {
    let letter = 'R';
    let symbol = '$';
    let crab = '🦀';
    println!("{letter} {symbol} {crab}");
}

Ausgabe:

R $ 🦀

▶ Selbst ausprobieren

Achtung

Einfache Anführungszeichen ('R') stehen für ein einzelnes char. Doppelte Anführungszeichen ("R") stehen für Text (Strings). Die beiden zu verwechseln ist ein typischer Anfängerfehler.

Strings (Text)

Text schreibst du in Rust in doppelten Anführungszeichen. Dir begegnen zwei String-Typen:

• &str – ein String-Slice, meistens Text, den du direkt in deinen Code schreibst (ein „String-Literal“).
• String – ein wachsender Text, der dir gehört und den du ändern und erweitern kannst.

fn main() {
    let greeting = "Hallo";              // &str
    let mut name = String::from("Ferris"); // String
    name.push_str(" die Krabbe");        // Strings können wachsen
    println!("{greeting}, {name}!");
}

Ausgabe:

Hallo, Ferris die Krabbe!

▶ Selbst ausprobieren

Den Unterschied zwischen &str und String musst du noch nicht verstehen. Er hängt mit Ownership (Eigentum) zusammen, das du bald kennenlernst. Fürs Erste gilt: Nimm "..." für Text und greif zu String, wenn du Text zusammenbauen oder ändern willst.

Typannotationen

Meistens erkennt Rust den Typ selbst. Manchmal braucht es aber einen Hinweis – zum Beispiel, wenn du Text in eine Zahl umwandelst (das siehst du auf der Seite Typumwandlung). Den Typ gibst du mit einem Doppelpunkt an:

let x: i32 = 42;
let y: f64 = 3.5;
let active: bool = true;

Kurzübersicht

Typ	Was er enthält	Beispiel
i32	Ganze Zahl (Standard)	let n = 42;
u32	Nicht negative ganze Zahl	let n: u32 = 42;
f64	Kommazahl (Standard)	let pi = 3.14;
bool	true oder false	let ok = true;
char	Ein Zeichen	let c = 'A';
&str	Text-Literal	let s = "hi";
String	Wachsender Text	let s = String::from("hi");

Übungen

1. Ein Spielerprofil

Beschreibe eine Spielfigur mit je einer Variable pro Typ: einem Namen (&str), einem Level (i32), einem Lebensenergie-Prozentwert (f64), einem Flag is_online (bool) und einem Rang-Buchstaben (char). Gib alles in einer Zeile aus. Tipp: Ein char steht in einfachen Anführungszeichen, Text in doppelten.

Lösung anzeigen

fn main() {
    let name = "Ferris";   // &str
    let level = 7;         // i32
    let health = 82.5;     // f64
    let is_online = true;  // bool
    let rank = 'A';        // char

    println!("{name} | Level {level} | {health}% | online: {is_online} | Rang {rank}");
}

Ausgabe:

Ferris | Level 7 | 82.5% | online: true | Rang A

▶ Selbst ausprobieren

2. Einen Satz bauen

Beginne mit String::from("Rust"), häng dann " ist schnell" und " und sicher" an und gib das Ergebnis aus. Tipp: Der String muss mit mut angelegt sein, damit push_str ihn ändern kann.

Lösung anzeigen

fn main() {
    let mut sentence = String::from("Rust");
    sentence.push_str(" ist schnell");
    sentence.push_str(" und sicher");
    println!("{sentence}");
}

Ausgabe:

Rust ist schnell und sicher

▶ Selbst ausprobieren

Zusammenfassung

• Jeder Wert hat einen Typ; Rust erkennt ihn meistens selbst.
• Ganze Zahlen → i32 (Standard). Kommazahlen → f64 (Standard).
• bool ist true/false; char ist ein einzelnes Zeichen in einfachen Anführungszeichen.
• Text steht in doppelten Anführungszeichen: &str für Literale, String für wachsenden Text.

Kurzer Check

Kurzer Check

1. Welcher Ganzzahltyp ist in Rust der Standard, wenn du keinen angibst?

u32 i32 i64

2. Woran unterscheidet Rust ein char-Literal von einem String-Literal?

Gar nicht – beide werden gleich geschrieben char-Literale stehen in einfachen, String-Literale in doppelten Anführungszeichen char-Literale stehen in doppelten, String-Literale in einfachen Anführungszeichen

3. Welcher Typ ist ein wachsender Text, der dir gehört und den du ändern kannst?

&str String char

4. Welcher Gleitkommatyp ist in Rust der Standard?

f32 f64 f128

5. Welchen Typ erkennt Rust bei let greeting = "Hallo";?

String &str char

Punkte: 0 / 5

Weiterlesen

• Datentypen – Die Programmiersprache Rust: alle skalaren Typen mit Größe und Wertebereich, dazu Ganzzahlüberlauf und die zusammengesetzten Typen (Tupel und Arrays).
• Primitives – Rust by Example (auf Englisch): lauffähige Beispiele zu jedem Grundtyp, mit einer Fortsetzung zu Literalen wie 1_000 und 0x80.
• i32 – Doku der Standardbibliothek (auf Englisch): der kleinste und größte Wert (i32::MIN, i32::MAX) und die vielen Methoden, die Zahlen haben.
• char – Doku der Standardbibliothek (auf Englisch): was ein Unicode-Skalarwert ist und warum ein char immer 4 Bytes groß ist.
• String – Doku der Standardbibliothek (auf Englisch): wie String und &str zusammenhängen, und alle Methoden zum Bauen und Ändern von Text.