From 51f91b8c2ca5ae8fca01fff75302a6c6e95d1ff4 Mon Sep 17 00:00:00 2001 From: Oliver Stolle3024383 Date: Wed, 10 Jun 2026 20:04:42 +0000 Subject: [PATCH] Implemented the homework exercises --- H-homework/Homework.md | 263 ++++++++++++++++++++++++++++++++++++++++- 1 file changed, 260 insertions(+), 3 deletions(-) diff --git a/H-homework/Homework.md b/H-homework/Homework.md index e30fb6f..3898b5f 100644 --- a/H-homework/Homework.md +++ b/H-homework/Homework.md @@ -2,8 +2,265 @@ ## 1. Ownership & Borrowing: -## 2. Pattern Matching +### Aufgabe 1: + +Erkläre, warum folgender Rust-Code nicht kompiliert: + +```rust +fn main() { + let s1 = String::from("Hallo"); + let s2 = s1; + + println!("{}", s1); +} +``` +Ändere den Code so, dass ```s1``` und ```s2``` augegeben werden können. +

+ + +### Aufgabe 2: + +Warum verbietet Rust folgenden Code? + +```rust +fn main() { + let mut text = String::from("Rust"); + + let r1 = &text; + let r2 = &mut text; + + println!("{}", r1); + println!("{}", r2); +} +``` +Schreibe den Code so um, sodass beide ```println!``` statements funktionieren. + +## 2. Pattern Matching & Enums: + +### Aufgabe 3: +Gegeben sei folgender Rust Code für eine 3-Phasen Ampel: +```rust +fn main(){ + enum Ampel { + Rot, + Gelb, + Gruen, + } + + let ampel_status = Ampel::Rot; + + match ampel_status { + Ampel::Rot => println!("STOP"), + Ampel::Gelb => println!("Achtung"), + Ampel::Gruen => println!("fahren"), + } +} +``` + +Ändere den Code in ```match ampel_status``` so ab, dass auch in ```Ampel``` beliebig viele andere Farben als Fahrsignal genutzt werden können. + +Was passiert wenn nicht alle Varainten in ```match ampel_status``` aufgelistet werden? + +## 3. Option & Result Types: + +### Aufgabe 4: + +Erkläre, warum folgender Code nicht funktioniert und behebe das Problem: + +```rust +fn main() { + let numbers = vec![1, 2, 3, 4, 5]; + let index = 10; + + let value = numbers[index]; + println!("Wert: {}", value); +} +``` + +Verwende `Option` oder eine andere Fehlerbehandlung, um sicher auf den Vektor zuzugreifen. Erkläre die Vorteile dieses Ansatzes gegenüber einem Laufzeitfehler ("panic"). + +
+ +### Aufgabe 5: + +Schreibe eine Funktion `parse_number`, die einen String nimmt und ein `Result` zurückgibt: +- Bei erfolgreicher Konvertierung: `Ok(zahl)` +- Bei Fehler: `Err("Ungültige Eingabe".to_string())` + +Verwende danach die Funktion in `main()` und behandle das `Result` mit `match`. + +```rust +fn parse_number(input: &str) -> Result { + // TODO: Implementierung +} + +fn main() { + // TODO: Funktion testen und Error Handling +} +``` + +Wie unterscheidet sich `Result` von `Option`? Wann verwendet man welchen Typ? + +## 4. String vs &str und Ownership: + +### Aufgabe 6: + +Erkläre den Unterschied zwischen `String` und `&str`. Warum verbietet Rust folgende Funktion zu kompilieren? + +```rust +fn greet(name: &str) { + println!("Hallo, {}!", name); +} + +fn main() { + let my_string = String::from("Alice"); + let string_slice = "Bob"; + + greet(my_string); // Fehler? + greet(string_slice); +} +``` + +Behebe den Fehler und erkläre, warum die Verwendung von `&str` als Parameter flexibler ist. + +
+ +### Aufgabe 7: + +Was ist der Unterschied zwischen folgenden zwei Funktionen? Welche ist besser und warum? + +```rust +// Variante 1: +fn create_greeting_1(name: String) -> String { + format!("Hallo, {}!", name) +} + +// Variante 2: +fn create_greeting_2(name: &str) -> String { + format!("Hallo, {}!", name) +} +``` + +Schreibe für beide Varianten ein Beispiel in `main()`, das die Flexibilität von Variante 2 demonstriert. + +## 5. Traits und Polymorphismus: + +### Aufgabe 8: + +Gegeben sind folgende Structs und ein Trait: + +```rust +struct Kreis { + radius: f64, +} + +struct Rechteck { + width: f64, + height: f64, +} + +trait Flaeche { + fn flaeche(&self) -> f64; +} +``` + +Implementiere den `Flaeche` Trait für beide Structs. Schreibe dann eine Funktion, die eine Referenz auf ein Objekt mit `Flaeche` Trait annimmt und dessen Fläche ausgibt. + +Bonus: Erstelle einen Vektor mit verschiedenen Formen und iteriere über sie. + + +## 6. Mutability und Interior Mutability: + +### Aufgabe 9: + +Erkläre, warum folgender Code nicht funktioniert: + +```rust +fn main() { + let counter = 0; + counter += 1; + println!("Counter: {}", counter); +} +``` + +Wie würde man diesen Code korrekt schreiben? Was ist der Unterschied zwischen `let mut` und Immutability? + +Gegeben ist ein Programm, das einen Counter mit einer Funktion erhöht: + +```rust +fn increment(counter: &mut i32) { + *counter += 1; +} + +fn main() { + let mut count = 0; + increment(&mut count); + println!("Counter: {}", count); +} +``` + +Erkläre die Rolle von `mut`, `&mut` und `*`. + +## 7. Lifetimes: + +### Aufgabe 10: + +Warum kompiliert folgender Code nicht und wie behebt man das Problem? + +```rust +fn longest(s1: &str, s2: &str) -> &str { + if s1.len() > s2.len() { + s1 + } else { + s2 + } +} + +fn main() { + let string1 = String::from("abc"); + let result; + { + let string2 = String::from("xyz"); + result = longest(&string1, &string2); + } + println!("{}", result); +} +``` + +Erkläre, was Lifetimes sind und warum Rust sie braucht. Behebe den Code mit korrekten Lifetime-Annotationen. + + +## 9. 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. + + + + + + + + -## 3. Enums -## 4. Lifetimes \ No newline at end of file