Primitive Typen

Rust ist eine Sprache mit statischer Typisierung. Das bedeutet, dass sie den Typ aller Variablen zum Zeitpunkt der Kompilierung kennen muss. Normalerweise kann der Compiler den Typ basierend auf dem zugewiesenen Wert ableiten, aber manchmal ist es notwendig oder nützlich, ihn manuell anzugeben.

Die primitiven Typen in Rust lassen sich in zwei Hauptkategorien einteilen: skalare (einzelner Wert) und zusammengesetzte (Gruppe von Werten) Typen.

Skalare Typen

Skalare Typen repräsentieren einen einzelnen Wert. Rust hat vier grundlegende:

1. Ganzzahlen: Zahlen ohne Komma. Sie können mit Vorzeichen (i8, i16, i32, i64, i128, isize) oder ohne Vorzeichen (u8, u16, u32, u64, u128, usize) sein. Der Standardtyp ist i32.
2. Gleitkommazahlen: Zahlen mit Komma. Sie können f32 oder f64 (doppelte Genauigkeit, Standard) sein.
3. Booleans: Repräsentieren den logischen Wahrheitswert mit true oder false (Typ bool).
4. Zeichen (Characters): Ein einzelner Unicode-Codepoint, der in einfache Anführungszeichen eingeschlossen ist (Typ char), z. B. 'a', 'ℤ' oder das Emoji '😻'.

Beispiel für eine explizite Typannotation:

let x: i64 = 42;
let y: f64 = 3.1415;
let is_rust_awesome: bool = true;
let heart_emoji: char = '❤';

Zusammengesetzte Typen

Zusammengesetzte Typen können mehrere Werte in einem einzigen Typ gruppieren. Rust hat zwei primäre zusammengesetzte Typen:

Tupel

Ein Tupel gruppiert Werte verschiedener Typen in einer Sammlung mit fester Größe:

let person: (String, i32) = (String::from("Alice"), 30);

// Destrutturazione per estrarre valori
let (name, age) = person;

// Accesso diretto con l'indice usando il punto (.)
let name_direct = person.0;
let age_direct = person.1;

Arrays (Vektoren mit fester Größe)

Ein Array gruppiert mehrere Elemente des gleichen Typs in einer Sammlung mit fester Größe, die auf dem Stack gespeichert wird:

let numbers = [1, 2, 3, 4, 5]; // Rilevato come [i32; 5]
let first = numbers[0]; // Accesso per indice
let third = numbers[2];

Wenn Sie versuchen, auf einen Index außerhalb der Array-Grenzen zuzugreifen (z. B. numbers[10]), bricht Rust die Ausführung zur Laufzeit sofort ab (Panic), anstatt unbefugten Speicherzugriff zuzulassen.

Vergleich zwischen Tupeln und Arrays

Probiere es aus