Basics größtenteils fertig, README überarbeitet

B-basics/4-arithmetik.rs

@@ -10,27 +10,31 @@ fn main() {
     let quotient: i32 = produkt / differenz;
     let modulo: i32 = quotient % 2;
 
-    println!("{summe}");
+    // Casting durch explizites angeben des Typs, implizit ist es nicht möglich
-    println!("{differenz}");
-    println!("{produkt}");
-    println!("{quotient}");
-    println!("{modulo}");
-
     // modulo benötigt jetzt keine 32 Bits, man kann es auch in i8 packen
     let moduloInKurz = modulo as i8;
     println!("{moduloInKurz}");
 
+    // Casting von Floating Point Zahlen
+    let eulerDoppelt: f64 = 2.71828182846;
+    println!("{eulerDoppelt}");
+    let eulerEinfach: f32 = eulerDoppelt as f32;
+    println!("{eulerEinfach}");
+
+    // Bei as Konvertierungen von Float in u8 kommt es beim Überschreiten der Grenze zu keinem Overflow, ab der Grenze wird abgeschnitten
+    println!(" 300.0 as u8 is : {}", 300.0_f32 as u8);
+    println!("-100.0 as u8 is : {}", -100.0_f32 as u8);
+    println!("   nan as u8 is : {}", f32::NAN as u8);
+
     // Man kann aber auch witzigere Sachen machen
     println!("{}", 10000000 as u8);
 
     // Casting mit Overflow ist dank der oberen Präprozessoranweisung möglich
-    let integer: i32 = -1234;
+    let integer: i32 = -12345;
     let unsigned = integer as u8;
     println!("{unsigned}");
 
     // Problemloses casten in char ist mit as nur möglich, wenn der Ursprungswert ein u8 ist
     let character = unsigned as char;
     println!("{character}");
-
-    
 }

B-basics/5-kontrollfluss.rs

@@ -19,6 +19,15 @@ fn main() {
 
     // For Loops sind etwas wilder, die klassische Java for-Loop (for (int i = 0; i <= 100; i++) {}) sehe so aus
     for i in 0..100 {
-        if i % 2 
+        // Das ist quasi der Ternary Operator aus Python
+        let gerade = if i % 2 == 0 { true } else { false }; // Semicolon wichtig, da das eine Variableninitialisierung ist
+
+        println!("{:?}", gerade);
+    }
+
+    // Loop läuft solange, bis ein break irgendwo erscheint, oder endlos
+    loop {
+        println!("Endlosschleifeeeee...");
+        break; // nicht mehr endlos
     }
 }

B-basics/8-structs.rs

@@ -8,6 +8,8 @@ struct Person {
     name: String,
     alter: u8,
 }
+// Um Methoden zu schreiben, die man über das Struct aufrufen kann durch einen Punkt, 
+// kann ein impl {} Block verwendet werden (siehe 9-funktionen.rs)
 
 fn main() {
     let semih = Person {

B-basics/9-funktionen.rs

@@ -1 +1,59 @@
-// Funktion ohne Rückgabewert returnt Unit (leeres Tupel)
+fn main() {
+    // Das ist die Main Funktion
+    // Diese Funktion wird beim Aufruf von rust-script und von cargo run ausgeführt
+    println!("{:?}", add(400, 20));
+    odd(67);
+    random_ausgabe();
+
+    // Durch STRUCTNAME::METHODENNAME() können die Funktionen aufgerufen werden, bspw ein Konstruktor um ein neues Struct zu erzeugen
+    let mut r = Rechteck::new(400.0, 20.0);
+    r.skalieren(4.0);
+    println!("{:?}", r.flaeche());
+}
+
+// Das ist eine Funktion, die ein Boolean zurück gibt, Parameter können in die Klammern geschrieben werden
+// Der zurückgebende Typ wird nach einem -> geschrieben
+fn add(a: i32, b: i32) -> i32 {
+    a + b // implizites return aka wenn der letzte Ausdruck einer Methode kein ; und kein return hat, wird dieses returnt
+}
+
+// Diese Funktion hat auch einen Rückgabewert, und zwar den Unit Typ "()"
+fn odd(a: i32) -> () {
+    if a % 2 == 1 {
+        println!("Ist ungerade");
+    } else {
+        println!("Ist gerade");
+    }
+}
+
+// Man kann das -> auch weglassen, dann wird automatisch die Unit zurück gegeben 
+fn random_ausgabe() {
+    println!("Funktion ohne Parameter und \"ohne\" Rückgabewert");
+}
+
+struct Rechteck {
+    hoehe: f64,
+    breite: f64,
+}
+
+// Ein impl, damit der Struct nicht ohne Nutzen ist
+impl Rechteck {
+    // Self (mit GROßEM S) == Klassenname in Java
+    fn new(breite: f64, hoehe: f64) -> Self {
+        Rechteck {
+            breite: breite,
+            hoehe: hoehe,
+        } // wieder implizit
+    }
+
+    // Aufruf durch referenz.flaeche
+    // self (mit KLEINEM s) == this in Java
+    fn flaeche(&self) -> f64 {
+        self.hoehe * self.breite // auch implizit
+    }
+
+    fn skalieren(&mut self, s: f64) {
+        self.hoehe *= s;
+        self.breite *= s;
+    }
+}

README.md

@@ -1,11 +1,12 @@
 # Rust PR3 Repository
 In diesem Repo sind alle Unterlagen für die Präsentation der Programmiersprache Rust
 Das Repo beinhaltet:
-- Dockerfile (TODO)
+- Dockerfile
 - Basics (TODO)
 - Ownership und Borrowing
 - Pattern Matching und Enumerationen (TODO)
 - Testing und Debugging (TODO)
+- Advanced Features von Rust (TODO)
 
 # Ablauf
 1. Warum Rust, (welche Apps), welche Entwicklungsumgebung (ca. 10 Minuten)
@@ -25,15 +26,28 @@ Das Repo beinhaltet:
 8. Vorstellung Hausaufgabe (ca. 5 Minuten)
 
 # Aufgabenbereich
-| Person  | Aufgabenbereich                     |
+- Semih Uguz (3025014)
-| ------- | ----------------------------------- |
+    - B-basics
-| Lukas   | Präsentieren, 4                     |
+    - C-cargo
-| Semih   | Präsentieren, 3                     |
+    - Präsentieren
-| Dominik | Präsentieren, 5, 6                  |
+    - Organisation des Repos
-| Vincent | Präsentieren und 8, Endpräsentation |
+- Lukas Müller (3017761)
-| Oliver  | Hausaufgabe, DevContainer           |
+    - D-ownership
-| Julian  | Einleitung & 7                      |
+    - Präsentieren
-
+    - Live Coding
-# Notizen
+- Oliver Stolle (3024383)
-- Cheat Sheet erstellen
+    - Dev Container
-- Tests für die Hausaufgabe erstellen
+    - Hausaufgabe
+- Julian Lenz (3008505)
+    - Fakten und Anwendungen von Rust
+    - Cheat Sheet
+    - Präsentieren
+    - G-advanced
+- Vincent Laux (3019006)
+    - Präsentieren
+    - Endpräsentation erstellen
+    - G-advanced
+- Dominik Stuck (3018438)
+    - Präsentieren
+    - E-enums
+    - F-testing