# Rust Rust ist eine moderne Systemprogrammiersprache, die mit Fokus auf Performance, Speichersicherheit und Nebenläufigkeit entwickelt wurde. Sie ermöglicht es Entwicklern, zuverlässige und effiziente Software zu erstellen, von Betriebssystemen bis hin zu Webanwendungen. ## Hello World! Das „Hello World!“ ist ein einfaches Programm, das Hello World! auf dem Bildschirm ausgibt. In Rust verwenden wir das Makro `println!()`, um eine Ausgabe auf der Konsole auszugeben. Beachte, dass `println!` mit `ln` endet: einem Kleinbuchstaben l (wie in „line“), nicht mit einem Großbuchstaben I. Der auszugebende Text wird innerhalb doppelter Anführungszeichen platziert und in Klammern eingeschlossen. Sehen wir uns das „Hello World!“-Programm in Rust an: ```rust fn main() { println!(„Hello World!“); } ``` ## Kommentare **Comments** sind Notizen, die man in den Code schreibt. Der compiler ignoriert sie vollständig – sie existieren nur, um Menschen beim Verständnis des Codes zu helfen. Um einen einzeiligen Kommentar zu schreiben, verwendet man `//`. Alles nach `//` bis zum Ende der Zeile wird ignoriert: ```rust // Das ist ein Kommentarprintln!("Hello, world!"); ``` Ein Kommentar kann auch am Ende einer Zeile nach dem Code geschrieben werden: ```rust println!("Hello, world!"); // Dies gibt Hello, world! aus! ``` Für Kommentare, die sich über mehrere Zeilen erstrecken, verwendet man `/*`, um zu beginnen, und `*/`, um zu enden: ```rust /* Dies ist ein mehrzeiliger Kommentar.   Der Compiler ignoriert ihn vollständig. */println!("Welcome!"); ``` Kommentare können eine Codezeile auch vorübergehend **deaktivieren**, ohne sie zu löschen: ```rust // println!("This line will NOT run");println!("This line will run"); ``` **Hinweis:** Jeder mehrzeilige Kommentar, der mit `/*` beginnt, muss mit `*/` geschlossen werden, andernfalls behandelt der Compiler alles danach als Kommentar. Grundlegende Programmstruktur In Rust beginnt jedes ausführbare Programm mit der Funktion `main`. Diese Funktion ist der Einstiegspunkt des Programms und dort beginnt die Ausführung. Die `function` `main` wird mit dem Schlüsselwort `fn`definiert, gefolgt von `main` und einem Klammerpaar `()`. Der auszuführende Code wird innerhalb geschweifter Klammern `{}` platziert. Hier ist eine einfache Aufschlüsselung eines grundlegenden Rust-Programms: ```rust fn main() { // Hauptfunktion    println!("Hello, Coddy!"); // Ausgabeanweisung} ``` Wichtiger Hinweis: In Rust muss jede Anweisung mit einem Semikolon (`;`) enden. Das Semikolon ist obligatorisch und teilt Rust mit, dass du das Ende einer Anweisung erreicht hast. Wenn du vergisst, ein Semikolon hinzuzufügen, führt dies zu einem Kompilierungsfehler. Beachte jedoch, dass Codeblöcke, die in geschweiften Klammern {} eingeschlossen sind (wie Funktionsdeklarationen), keine Semikolons benötigen. ## Grundlegende Programmstruktur In Rust beginnt jedes ausführbare Programm mit der Funktion `main`. Diese Funktion ist der Einstiegspunkt des Programms und dort beginnt die Ausführung. Die `function` `main` wird mit dem Schlüsselwort `fn`definiert, gefolgt von `main` und einem Klammerpaar `()`. Der auszuführende Code wird innerhalb geschweifter Klammern `{}` platziert. Hier ist eine einfache Aufschlüsselung eines grundlegenden Rust-Programms: ```rust fn main() { // Hauptfunktion     println!("Hello, Coddy!"); // Ausgabeanweisung } ``` Wichtiger Hinweis: In Rust muss jede Anweisung mit einem Semikolon (`;`) enden. Das Semikolon ist obligatorisch und teilt Rust mit, dass du das Ende einer Anweisung erreicht hast. Wenn du vergisst, ein Semikolon hinzuzufügen, führt dies zu einem Kompilierungsfehler. Beachte jedoch, dass Codeblöcke, die in geschweiften Klammern `{}` eingeschlossen sind (wie Funktionsdeklarationen), keine Semikolons benötigen. ## Zahlen **Variablen** sind Container, die Datenwerte enthalten. Sie werden verwendet, um Informationen innerhalb eines Programms zu speichern, zu manipulieren und anzuzeigen. Kurz gesagt ist eine Variable wie eine Speichereinheit, auf die wir zugreifen können, indem wir den Namen der Variable eingeben.  Jede Variable hat einen eindeutigen **Namen** und einen **Wert**, der von unterschiedlichem Typ sein kann. Rust verfügt über verschiedene integrierte Datentypen, die den Typ des Wertes definieren, den eine Variable enthalten kann. Um eine Variable zu initialisieren, verwenden wir das folgende **Format**: ```rust let variable_name: variable_type = value; ``` In Rust werden Zahlen normalerweise mit zwei Hauptdatentypen dargestellt: `i32` und `f64`. `i32` wird verwendet, um ganze Zahlen ohne Dezimalpunkt zu speichern. Zum Beispiel: ```rust let age: i32 = 30; let temperature: i32 = -5; let count: i32 = 100; ``` `f64` wird verwendet, um Zahlen mit einem Dezimalpunkt zu speichern. Zum Beispiel: ```rust let price: f64 = 99.99; let pi: f64 = 3.14159; let fraction: f64 = 0.5; ``` Beim Deklarieren von Variablen in Rust müssen Sie den Typ der Variable nach dem Variablennamen angeben, gefolgt von einem Doppelpunkt. Dies wird als **Typdeklaration** bezeichnet. Sobald eine Variable mit einem bestimmten Typ deklariert wurde, kann sie nur Werte dieses Typs enthalten. ### Challenge Schreiben Sie ein Rust-Programm, das die folgenden Variablen deklariert und initialisiert: - Deklarieren Sie eine `i32`-Variable namens `quantity`und initialisieren Sie diese mit dem Wert `5`. - Deklarieren Sie eine `f64`-Variable namens `item_price`und initialisieren Sie diese mit dem Wert `24.99`. Nachdem Sie diese Variablen deklariert und initialisiert haben, verwenden Sie `println!()`, um die Werte der Variablen im folgenden Format auf der Konsole auszugeben: ```rust Quantity: [value of quantity] Price: [value of item_price] ``` #### Lösung: ```rust fn main() { // Variablen hier deklarieren und initialisieren let quantity: i32 = 5; let item_price: f64 = 24.99; println!("Quantity: {}", quantity); println!("Price: {}", item_price); } ``` ## Char Ein **char** ist ein einzelnes Zeichen (Zum Beispiel: `1, 6, %, b, p, ., T`, etc.) Der **char**-Typ ist ein spezieller Typ, der aus einem einzelnen Zeichen besteht. Um einen char-Wert in einer Variablen zu initialisieren, schließen Sie ihn in **einfache Anführungszeichen** ein: ```rust let c1: char = 'h'; ``` Im obigen Beispiel wird eine char-Variable namens `c1`initialisiert.