0Pricing
Learn Rust Coding · Lektion

Primitive Datentypen und Operatoren

Erkunden Sie die integrierten primitiven Datentypen von Rust wie Ganzzahlen, Gleitkommazahlen, boolesche Werte und Zeichen sowie gängige Operatoren.

Primitive Datentypen und Operatoren ist eine kostenlose Learn Rust Coding-Lektion auf CoddyKit. Dies ist Lektion 2 von 3. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Learn Rust Coding-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Learn Rust Coding-Kurs umfasst insgesamt 3 Lektionen.

Einführung in primitive Datentypen

Willkommen zu einer grundlegenden Lektion über Rust! Heute sehen wir uns primitive Datentypen und grundlegende Operatoren an.

Primitive Typen sind die fundamentalsten Bausteine zum Speichern von Daten. Sie repräsentieren einfache Werte wie Zahlen, Wahrheitswerte oder einzelne Zeichen.

Das Verständnis dieser Typen ist entscheidend, um effizienten und korrekten Rust-Code zu schreiben.

Ganzzahltypen in Rust

Rust stellt verschiedene Ganzzahltypen für unterschiedliche Anforderungen bereit. Sie gibt es in zwei Hauptvarianten:

  • Vorzeichenbehaftete Ganzzahlen (Präfix i): Können positive und negative Zahlen speichern (z. B. i8, i32, i64).
  • Vorzeichenlose Ganzzahlen (Präfix u): Können nur positive Zahlen oder null speichern (z. B. u8, u32, u64).

Die Zahl gibt die Anzahl der Speicherbits an, z. B. ist i32 eine vorzeichenbehaftete 32-Bit-Ganzzahl. isize und usize sind Ganzzahlen in Zeigergröße und passen sich an die Architektur Ihres Systems an (32 oder 64 Bit).

Ganzzahlvariablen deklarieren

Sehen wir uns an, wie Ganzzahltypen in Rust deklariert und verwendet werden. Beachten Sie, dass wir entweder ausdrücklich eine Typannotation hinzufügen oder Rust den Typ herleiten lassen können.

Führen Sie dieses Beispiel aus:

fn main() {
  let signed_val: i32 = -100;
  let unsigned_val: u32 = 250;
  let inferred_int = 500; // Rust infers i32 by default
  let big_unsigned: u64 = 1_000_000_000;

  println!("Signed: {}", signed_val);
  println!("Unsigned: {}", unsigned_val);
  println!("Inferred: {}", inferred_int);
  println!("Big Unsigned: {}", big_unsigned);
}

Gleitkommazahlen

Für Zahlen mit Dezimalpunkten bietet Rust Gleitkommatypen:

  • f32: Gleitkommazahl mit einfacher Genauigkeit (32 Bit).
  • f64: Gleitkommazahl mit doppelter Genauigkeit (64 Bit). Dies ist der standardmäßige Gleitkommatyp in Rust.

f64 wird aufgrund der höheren Genauigkeit im Allgemeinen für die meisten Anwendungen bevorzugt, sofern keine besonderen Einschränkungen hinsichtlich Speicher oder Leistung bestehen.

Gleitkommavariablen deklarieren

So deklarieren Sie Gleitkommazahlen. Beachten Sie, dass Rust standardmäßig f64 verwendet, wenn Sie keinen Typ angeben.

Führen Sie dieses Beispiel aus:

fn main() {
  let pi: f32 = 3.14159;
  let e = 2.718281828; // Inferred as f64
  let temperature: f64 = 98.6;

  println!("Pi (f32): {}", pi);
  println!("E (f64 inferred): {}", e);
  println!("Temperature (f64): {}", temperature);
}

Boolesche Werte und Zeichen

Neben Zahlen bietet Rust Typen für logische Werte und einzelne Zeichen:

  • bool: Stellt einen Wahrheitswert dar, entweder true oder false.
  • char: Stellt einen einzelnen Unicode-Skalarwert dar. Das bedeutet, dass ein char mehr als nur ASCII enthalten kann – es kann ein beliebiger Buchstabe, ein Emoji oder ein Symbol sein.

Ein char benötigt 4 Byte Speicher, sodass jedes Unicode-Zeichen gespeichert werden kann.

Boolesche Werte und Zeichen in Aktion

Deklarieren wir einige Variablen für boolesche Werte und Zeichen. Beachten Sie die einfachen Anführungszeichen bei char-Werten.

Führen Sie dieses Beispiel aus:

fn main() {
  let is_rust_fun: bool = true;
  let has_errors = false; // Inferred as bool
  let first_letter: char = 'R';
  let emoji_char: char = '🚀';

  println!("Is Rust fun? {}", is_rust_fun);
  println!("Has errors? {}", has_errors);
  println!("First letter: {}", first_letter);
  println!("Emoji: {}", emoji_char);
}

Grundlegende arithmetische Operatoren

Wie in der Mathematik verwendet Rust Operatoren für Berechnungen. Hier sind die wichtigsten arithmetischen Operatoren:

  • +: Addition
  • -: Subtraktion
  • *: Multiplikation
  • /: Division
  • %: Rest (Modulo)

Denken Sie daran, dass die Ganzzahldivision (z. B. 10 / 3) den Dezimalteil abschneidet und eine Ganzzahl ergibt (3, nicht 3.33).

Arithmetische Operatoren verwenden

Wenden wir diese Operatoren mit einigen Zahlen an. Achten Sie darauf, wie sich die Ganzzahldivision verhält!

Führen Sie dieses Beispiel aus:

fn main() {
  let a = 15;
  let b = 4;

  println!("Addition: 15 + 4 = {}", a + b);
  println!("Subtraction: 15 - 4 = {}", a - b);
  println!("Multiplication: 15 * 4 = {}", a * b);
  println!("Integer Division: 15 / 4 = {}", a / b);
  println!("Remainder: 15 % 4 = {}", a % b);

  let x = 15.0;
  let y = 4.0;
  println!("Float Division: 15.0 / 4.0 = {}", x / y);
}

Quiz zu primitiven Datentypen

Testen Sie Ihr Verständnis der primitiven Datentypen und grundlegenden Operatoren von Rust.

Rückblick: Primitive Datentypen und Operatoren

Sehr gut! Sie haben die grundlegenden Datentypen von Rust kennengelernt:

  • Ganzzahlen: i8, u8, i32, u32 usw. für ganze Zahlen.
  • Gleitkommazahlen: f32 und f64 für Dezimalzahlen.
  • Boolesche Werte: bool für true oder false.
  • Zeichen: char für einzelne Unicode-Werte.

Außerdem haben Sie grundlegende arithmetische Operatoren wie +, -, *, / und % kennengelernt. Sie bilden die Grundlage für komplexere Logik in Ihren Programmen.

Häufig gestellte Fragen

Ist die Lektion „Primitive Datentypen und Operatoren“ kostenlos?

Ja — der vollständige Text von „Primitive Datentypen und Operatoren“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Learn Rust Coding-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Learn Rust Coding-Kurs umfasst insgesamt 3 Lektionen.

Was lerne ich in „Primitive Datentypen und Operatoren“?

Erkunden Sie die integrierten primitiven Datentypen von Rust wie Ganzzahlen, Gleitkommazahlen, boolesche Werte und Zeichen sowie gängige Operatoren. Du übst Learn Rust Coding mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Learn Rust Coding zu starten?

Keine Vorkenntnisse erforderlich. Learn Rust Coding auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 3.

Wie lange dauert die Lektion „Primitive Datentypen und Operatoren“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Learn Rust Coding-Lektion Code schreiben und ausführen?

Ja. Jede Learn Rust Coding-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. Variablen, Veränderlichkeit und Shadowing
  2. Primitive Datentypen und Operatoren
  3. Funktionen und Kontrollfluss
← Zurück zu Learn Rust Coding