From c4f93b7ab047010649163e00ffca6cb242d5d620 Mon Sep 17 00:00:00 2001 From: Semih <3025014@stud.hs-mannheim.de> Date: Mon, 15 Jun 2026 22:06:45 +0200 Subject: [PATCH] Letzten Feinschliff gemacht --- B-basics/1-variablen.rs | 2 +- B-basics/10-funktionen.rs | 2 +- B-basics/11-traits.rs | 51 ++++++++++++++++++++++++++++ B-basics/2-konstanten.rs | 1 - B-basics/3-datentypen.rs | 4 +++ B-basics/5-kontrollfluss.rs | 5 +++ B-basics/6-print.rs | 2 ++ B-basics/7-compounds.rs | 34 ++++++++++++++++++- B-basics/8-structs.rs | 2 +- B-basics/9-enums.rs | 5 ++- {F-error => F-testing}/01_testing.rs | 0 G-concurrency/TODO | 0 H-advanced/TODO | 0 H-advanced/result.rs | 0 I-homework/Homework.md | 24 ------------- README.md | 6 +++- 16 files changed, 105 insertions(+), 33 deletions(-) create mode 100644 B-basics/11-traits.rs rename {F-error => F-testing}/01_testing.rs (100%) delete mode 100644 G-concurrency/TODO delete mode 100644 H-advanced/TODO delete mode 100644 H-advanced/result.rs diff --git a/B-basics/1-variablen.rs b/B-basics/1-variablen.rs index 068d14b..40e158d 100644 --- a/B-basics/1-variablen.rs +++ b/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}"); { diff --git a/B-basics/10-funktionen.rs b/B-basics/10-funktionen.rs index 1c3f2bc..850b968 100644 --- a/B-basics/10-funktionen.rs +++ b/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 diff --git a/B-basics/11-traits.rs b/B-basics/11-traits.rs new file mode 100644 index 0000000..a92a4f0 --- /dev/null +++ b/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(); +} diff --git a/B-basics/2-konstanten.rs b/B-basics/2-konstanten.rs index a442d2a..46ff5b6 100644 --- a/B-basics/2-konstanten.rs +++ b/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}"); diff --git a/B-basics/3-datentypen.rs b/B-basics/3-datentypen.rs index 41ec290..844155e 100644 --- a/B-basics/3-datentypen.rs +++ b/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 diff --git a/B-basics/5-kontrollfluss.rs b/B-basics/5-kontrollfluss.rs index 137ff3e..eb60abb 100644 --- a/B-basics/5-kontrollfluss.rs +++ b/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 { diff --git a/B-basics/6-print.rs b/B-basics/6-print.rs index af75859..92c6fb1 100644 --- a/B-basics/6-print.rs +++ b/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); diff --git a/B-basics/7-compounds.rs b/B-basics/7-compounds.rs index ac3ec94..1110376 100644 --- a/B-basics/7-compounds.rs +++ b/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); } diff --git a/B-basics/8-structs.rs b/B-basics/8-structs.rs index 81ef8a7..0679384 100644 --- a/B-basics/8-structs.rs +++ b/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() { diff --git a/B-basics/9-enums.rs b/B-basics/9-enums.rs index a29dcdf..875e034 100644 --- a/B-basics/9-enums.rs +++ b/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, -} \ No newline at end of file +} diff --git a/F-error/01_testing.rs b/F-testing/01_testing.rs similarity index 100% rename from F-error/01_testing.rs rename to F-testing/01_testing.rs diff --git a/G-concurrency/TODO b/G-concurrency/TODO deleted file mode 100644 index e69de29..0000000 diff --git a/H-advanced/TODO b/H-advanced/TODO deleted file mode 100644 index e69de29..0000000 diff --git a/H-advanced/result.rs b/H-advanced/result.rs deleted file mode 100644 index e69de29..0000000 diff --git a/I-homework/Homework.md b/I-homework/Homework.md index 9979596..629169f 100644 --- a/I-homework/Homework.md +++ b/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` - -```rust -fn divide(a: f64, b: f64) -> Result { - // 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. diff --git a/README.md b/README.md index 2e0ae52..6ef2585 100644 --- a/README.md +++ b/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