Primitive Datentypen

Was Rust zu „primitiv" zählt

Streng genommen ist nichts in Rust eine „eingebaute" Klasse — alle Typen sind Werte mit Methoden, die in Crates oder der Standard-Library leben. Was man unter primitive Typen versteht, sind die Typen mit speziellem Compiler-Support und Literal-Syntax:

• Integer-Typen — i8, i16, i32, i64, i128, isize, u8, u16, u32, u64, u128, usize. Zehn Familien, die explizit zwischen Vorzeichen-behaftet (i) und vorzeichenlos (u) sowie zwischen festgelegten Bitbreiten und plattformabhängigen (size) unterscheiden.
• Float-Typen — f32 und f64, beide nach IEEE 754. Default ist f64.
• bool — true und false. Strikt: kein automatisches Casting zu Integer.
• char — ein 4-Byte Unicode-Scalar-Value. Nicht zu verwechseln mit C-char (1 Byte) oder einem UTF-8-Byte in einem String.
• Tupel — heterogene Sequenzen mit fester Länge, z. B. (i32, f64, &str).
• Arrays — homogene Sequenzen mit zur Compile-Zeit bekannter Länge, z. B. [u8; 32].
• Slices — Views in zusammenhängenden Speicher: &[T] und &mut [T]. Streng genommen kein eigener Typ pro Wert, sondern ein Referenz-Typ.
• Unit () und Never ! — die zwei „Sonder"-Typen, die in vielen Sprachen unbenannt vorkommen, in Rust aber sichtbar sind.

---

Artikel in diesem Kapitel

• Integer-Typen — die zehn Integer-Familien, Default-Inferenz, Suffixe, Hex/Oct/Bin-Literale, Overflow-Verhalten in Debug vs. Release, sichere Arithmetik mit checked_*/wrapping_*/saturating_*-Methoden.
• Float-Typen — f32 und f64 nach IEEE 754, NaN/Infinity, warum es nur PartialOrd ist, klassische Präzisions-Fallen und sichere Vergleichs-Patterns.
• bool — wirklich nur zwei Werte, kein Truthy/Falsy, hilfreiche Methoden wie then und then_some, sicheres Casten zwischen bool und Integer.
• char — der 4-Byte-Unicode-Scalar, Iteration über String::chars(), Escape-Sequenzen, der Unterschied zu UTF-8-Bytes.
• Tuple — heterogene Bündel mit Feldzugriff per .0, Destrukturierung, der Spezialfall Unit () und der Vergleich zu Tuple-Structs.
• Array — [T; N] als Stack-allokierte Sequenz mit fester Länge, Initialisierungs-Patterns, Out-of-Bounds-Panic und die Abgrenzung zu Vec und Slice.
• Slice — &[T] und &mut [T] als „Fat Pointer" über Daten plus Länge, die wichtigsten Slice-Methoden und ein Ausblick auf &str als String-Slice-Variante.
• Unit und Never — das leere Tupel () als „kein Wert" und der Never-Type ! für divergierende Pfade (panic, return, loop).
• Numeric Conversions — as mit allen Fallen, From/Into für verlustfreie Konvertierungen, TryFrom/TryInto für fallible Fälle.

Was du nach diesem Kapitel kannst

• Die passende Integer-Familie für eine Aufgabe wählen (Compile-Zeit-Bitbreite vs. plattformabhängig, signed vs. unsigned).
• Float-Vergleiche sicher schreiben — ohne im NaN-Loch zu landen.
• char korrekt vom UTF-8-Byte unterscheiden und Strings über Code-Points iterieren.
• Tupel und Arrays als leichtgewichtige Werte einsetzen und ihre Grenzen kennen.
• Slices verstehen — Vorbereitung auf alles, was später in Iteratoren und Collections kommt.
• as-Casts vermeiden, wo From/Into ausreichen, und TryFrom für fehleranfällige Konvertierungen nutzen.

Im nächsten Kapitel geht es um Strings und Text — str, String, UTF-8-Iteration, Formatierung und die Sonderrolle von Cow<str>.

Weiterführende Ressourcen

Externe Quellen

• The Rust Book – Data Types
• Rust Reference – Types
• std – Primitive Type Documentation
• Rust by Example – Primitives

Verwandte Artikel

• Integer-Typen
• Float-Typen
• bool
• char
• Tuple
• Array
• Slice
• Unit und Never
• Numeric Conversions