Letzten Feinschliff gemacht

B-basics/1-variablen.rs

@@ -10,7 +10,7 @@ fn main() {
     y += 1; // Das funktioniert
     println!("{y}");
 
-    let x = 187; // Shadowing: es wird eine neue Viariable mit dem selben Namen erstellt, dieser überschattet die vorherige Variable
+    let x = 187; // Shadowing: es wird eine neue Variable mit dem selben Namen erstellt, dieser überschattet die vorherige Variable
     println!("{x}");
 
     {

B-basics/10-funktionen.rs

@@ -18,7 +18,7 @@ fn main() {
     inspect(person);    
 }
 
-// Das ist eine Funktion, die ein Boolean zurückgibt, Parameter können in die Klammern geschrieben werden
+// Das ist eine Funktion, die ein Integer zurückgibt, 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

B-basics/11-traits.rs

@@ -0,0 +1,51 @@
+// Mit Interfaces aus Java vergleichbar
+trait Flieger {
+    fn new() -> Self; // Eine new Funktion, um ein Struct zurück zu geben
+    fn fliegen(&self); // Instanzmethode, die Zeug macht, das noch nicht bekannt ist
+    fn landen(&self);
+}
+
+struct Flugeug {}
+
+struct Ente {}
+
+// Hier implementieren wir die Methoden vom Flieger Trait für Flugzeug
+impl Flieger for Flugeug {
+    fn new() -> Self {
+        return Flugeug {};
+    }
+
+    fn fliegen(&self) {
+        println!("Ich heb ab, nichts hält mich am Boden");
+    }
+
+    fn landen(&self) {
+        println!("Party vorbei, ich lande")
+    }
+}
+
+// Hier implementieren wir die Methoden vom Flieger Trait für Ente
+impl Flieger for Ente {
+    fn new() -> Self {
+        return Ente {};
+    }
+
+    fn fliegen(&self) {
+        println!("Quak, ich fliege, quak");
+    }
+
+    fn landen(&self) {
+        println!("Quak, ich lande nun, quak");
+    }
+}
+
+fn main() {
+    let flugzeug: Flugeug = Flieger::new();
+    let ente: Ente = Flieger::new();
+
+    flugzeug.fliegen();
+    flugzeug.landen();
+
+    ente.fliegen();
+    ente.landen();
+}

B-basics/2-konstanten.rs

@@ -16,7 +16,6 @@ fn main() {
     static WITZIGERES: i8 = 25;
     println!("Ich weiß noch was witzigeres als {WITZIGES}\nNa was denn?\n{WITZIGERES} hahahaha");
 
-
     // Da static mut unsafe ist, können sie nur in solchen unsafe Blöcken verändert und gelesen werden, anders nicht
     unsafe {
         println!("Aktueller Präsentierer ist: {PRAESENTIERER}");

B-basics/3-datentypen.rs

@@ -1,10 +1,12 @@
 fn main() {
+    println!("Integer:\n-----");
     // Ganzzahlen
     let integer: i32 = -420; // Es gibt Integer mit unterschiedlicher Bitlänge (8, 16, 32, 64, 128 oder architekturspezifisch (isize))
     println!("{integer}");
     let unsigned: u32 = 420; // Unsigned Integer mit unterschiedlicher Bitlänge (8, 16, 32, 64, 128 oder architekturspezifisch (usize))
     println!("{unsigned}");
 
+    println!("\nInteger Literale:\n-----");
     // Integer Literale geben unterschiedliche Zahlensysteme an
     let integer = 98_765; // Dezimal (Unterstriche als Trennzeichen erlaubt)
     println!("{integer}");
@@ -21,6 +23,7 @@ fn main() {
     let byte = b'A';
     println!("{byte}");
 
+    println!("\nFloating Point:\n-----");
     // Gleitkommazahlen
     let einfach: f32 = 3.14; // Einfache Genauigkeit (wie float in Java)
     println!("{einfach}");
@@ -28,6 +31,7 @@ fn main() {
     let doppelt: f64 = 3.14159265359; // Doppelte Genauigkeit (wie double in Java) -- Standardwert
     println!("{doppelt}");
 
+    println!("\nBoolean und Char:\n-----");
     let boolean: bool = true; // Boolean (true oder false)
     println!("{boolean}");
     println!("{}", !boolean); // Wert negieren

B-basics/5-kontrollfluss.rs

@@ -1,6 +1,7 @@
 fn main() {
     let mut x = 0;
 
+    println!("If Else:\n-----");
     // If Bedingungen sind sehr ähnlich zu anderen Sprachen
     if x == 0 {
         println!("x ist Null");
@@ -10,6 +11,7 @@ fn main() {
         println!("x ist positiv");
     }
 
+    println!("\nWhile:\n-----");
     // While Schleifen wie in Java, nur ohne Klammen
     // Klammern dürfen dabei stehen, das würde aber ein Warning ausgeben
     while x < 10 {
@@ -17,6 +19,7 @@ fn main() {
         x += 1;
     }
 
+    println!("\nFor:\n-----");
     // For Loops sind etwas wilder, die klassische Java for-Loop (for (int i = 0; i < 10; i++) {}) sehe so aus
     for i in 0..10 {
         // Das ist quasi der Ternary Operator aus Python
@@ -25,12 +28,14 @@ fn main() {
         println!("{:?}", gerade);
     }
 
+    println!("\nLoop:\n-----");
     // Loop läuft solange, bis ein break irgendwo erscheint, oder endlos
     loop {
         println!("Endlosschleifeeeee...");
         break; // nicht mehr endlos
     }
 
+    println!("\nMatch:\n-----");
     for tag in 1..8 {
         // Switch Case werden realisiert durch Pattern Matching
         match tag {

B-basics/6-print.rs

@@ -4,6 +4,7 @@ fn main() {
     println!("Hier geschieht eine Textausgabe in die Standardausgabe");
     println!("{}", "Die geschweiften Klammern sind quasi die Escape Zeichen der printf() Funktion aus C");
 
+    println!("\nVariablen:\n-----");
     let x = 42;
     // Wenn der Name der Variable in die geschweiften Klammern geschrieben wird, kann diese auch ausgegeben werden
     println!("Variablen können deklariert und somit in die Standardausgabe geschrieben werden: x = {x}");
@@ -23,6 +24,7 @@ fn main() {
     let array = [1, 2, 3, 4];
     println!("{:?}", array); // Das ? gibt an, dass es eine Debug Ausgabe ist
 
+    println!("\nZahlensysteme:\n-----");
     // Zahlen können in unterschiednlichen Zahlensystemen ausgegeben werden
     println!("x in Binär = {:b}", x);
     println!("x in Oktal = {:o}", x);

B-basics/7-compounds.rs

@@ -1,16 +1,19 @@
 fn main() {
     // Dieser String ist ein String Slice, welcher eine unveränderliche Referenz auf einen bestehenden String ist
-    let string: &str = "Das ist ein String."; 
+    println!("Strings:\n-----");
+    let string: &str = "Das ist ein String.";
     println!("{string}");
 
     // Ein im Heap allokierter, veränderlicher und besitzender String, mehr dazu später
     let string = String::from("Das ist auch ein String.");
     println!("{string}");
 
+    println!("\nTupel:\n-----");
     let tupel = (42, "Das hier ist ein Tupel.", true);
     let (a, b, c) = tupel;
     println!("{}, {}, {}", a, b, c);
 
+    println!("\nArrays und Slices:\n-----");
     let array: [&str; 5] = ["Das", " ist", " ein", " Array", "."]; // Es wird explizit geschrieben, welche Größe es hat
     println!("{:?}", array);
 
@@ -20,4 +23,33 @@ fn main() {
     println!("{}", element);
 
     println!("{}", array.len()); // Länge kann ausgegeben werden
+
+    let ganzer_slice = &array; // Ein Slice, der auf das angegebene Array zeigt
+    let teil_slice = &array[1..4]; // Ein Slice, der nur auf ein bestimmten Teil des Arrays zeigt
+
+    println!("{:?}", ganzer_slice);
+    println!("{:?}", teil_slice);
+
+    println!("\nVektoren:\n-----");
+    let mut vektor = vec![1, 2, 3]; // Ein Vektor, dessen Einträge dynamisch verringert oder vergößert werden kann
+    println!("{:?}", vektor);
+    
+    // Einige Methoden, die man auf Vektoren anwenden kann
+    vektor.push(4);
+    println!("{:?}", vektor);
+
+    vektor.insert(2, 20); // (index, wert)
+    println!("{:?}", vektor);
+
+    vektor.extend(array);
+    println!("{:?}", vektor);
+
+    vektor.remove(2);
+    println!("{:?}", vektor);
+
+    vektor.pop();
+    println!("{:?}", vektor);
+
+    vektor.clear();
+    println!("{:?}", vektor);
 }

B-basics/8-structs.rs

@@ -8,7 +8,7 @@ struct Person {
     name: String,
     alter: u8,
 }
-// Um Methoden zu schreiben, die man über das Struct aufrufen kann durch einen Punkt, 
+// 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() {

B-basics/9-enums.rs

@@ -2,14 +2,13 @@
 #[allow(unused_variables)]
 
 fn main() {
-    // Beides macht dasselbe
     let semih = Hochschule::Student;
     let steger = Hochschule::Professor;
 
     // Durch Enums kann Pattern Matching in etwas sehr wertvolles umgewandelt werden
     match semih {
         Hochschule::Student => println!("Ich bin ein armer Student :("),
-        Hochschule::Professor => println!("Ich bin ein Professor :)")
+        Hochschule::Professor => println!("Ich bin ein Professor :)"),
     }
 }
 
@@ -17,4 +16,4 @@ fn main() {
 enum Hochschule {
     Student,
     Professor,
-}
+}

I-homework/Homework.md

@@ -204,27 +204,3 @@ fn main() {
 ```
 
 Erkläre, was Lifetimes sind und warum Rust sie braucht. Behebe den Code mit korrekten Lifetime-Annotationen.
-
-
-## 8. Error Handling und Panic:
-### Aufgabe 11:
-Was ist der Unterschied zwischen `panic!` und `Result`? Wann sollte man welches verwenden?
-
-Schreibe eine Funktion `divide`, die zwei Zahlen dividiert:
-- Bei erfolgreicher Division: Rückgabe des Ergebnisses
-- Bei Division durch Null: Rückgabe eines fehlers als `Result<f64, String>`
-
-```rust
-fn divide(a: f64, b: f64) -> Result<f64, String> {
-    // TODO
-}
-
-fn main() {
-    match divide(10.0, 2.0) {
-        Ok(result) => println!("Ergebnis: {}", result),
-        Err(e) => println!("Fehler: {}", e),
-    }
-}
-```
-
-Erkläre, warum `Result` sicherer ist als ein `panic!` in einer Library-Funktion.

README.md

@@ -48,7 +48,11 @@ Link zur Präsentation: https://docs.google.com/presentation/d/1vkq-cDprBH-5ya1V
     - Cheat Sheet
     - Präsentieren
     - Concurrency
+    - Teile von Advanced
 - Vincent Laux (3019006)
     - Präsentieren
     - Endpräsentation erstellen
-- Dominik Stuck (3018438) (aktuell noch nichts gemacht)
+- Dominik Stuck (3018438)
+    - Enums
+    - Testing
+    - Präsentieren