Basics erweitert und README aktualisiert
parent
047a060968
commit
d9da49d8b9
|
|
@ -1,3 +1,5 @@
|
|||
#[allow(dead_code)]
|
||||
|
||||
fn main() {
|
||||
// Das ist die Main Funktion
|
||||
// Diese Funktion wird beim Aufruf von rust-script und von cargo run ausgeführt
|
||||
|
|
@ -9,6 +11,11 @@ fn main() {
|
|||
let mut r = Rechteck::new(400.0, 20.0);
|
||||
r.skalieren(4.0);
|
||||
println!("{:?}", r.flaeche());
|
||||
|
||||
use Arbeit::*; // Use dafür, damit man nicht immer Arbeit:: schreiben muss
|
||||
let person = Arbeitnehmer;
|
||||
|
||||
inspect(person);
|
||||
}
|
||||
|
||||
// Das ist eine Funktion, die ein Boolean zurückgibt, Parameter können in die Klammern geschrieben werden
|
||||
|
|
@ -57,3 +64,16 @@ impl Rechteck {
|
|||
self.breite *= s;
|
||||
}
|
||||
}
|
||||
|
||||
enum Arbeit {
|
||||
Arbeitnehmer,
|
||||
Arbeitgeber,
|
||||
Selbstaendiger,
|
||||
}
|
||||
|
||||
fn inspect(person: Arbeit) {
|
||||
match person {
|
||||
Arbeit::Arbeitnehmer => println!("Grrr, Chefs"),
|
||||
_ => println!("Grrr, Steuern"),
|
||||
}
|
||||
}
|
||||
|
|
@ -17,8 +17,8 @@ fn main() {
|
|||
x += 1;
|
||||
}
|
||||
|
||||
// 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 {
|
||||
// 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
|
||||
let gerade = if i % 2 == 0 { true } else { false }; // Semicolon wichtig, da das eine Variableninitialisierung ist
|
||||
|
||||
|
|
@ -30,4 +30,32 @@ fn main() {
|
|||
println!("Endlosschleifeeeee...");
|
||||
break; // nicht mehr endlos
|
||||
}
|
||||
|
||||
for tag in 1..8 {
|
||||
// Switch Case werden realisiert durch Pattern Matching
|
||||
match tag {
|
||||
1 => println!("Montag :O"),
|
||||
2 => println!("Dienstag >:("),
|
||||
3 => println!("Mittwoch :("),
|
||||
4 => println!("Donnerstag :|"),
|
||||
5 => println!("Freitag :)"),
|
||||
6 => println!("Samstag :D"),
|
||||
7 => println!("Sonntag :D"),
|
||||
_ => println!("Tag unbekannt"), // Default Fall
|
||||
}
|
||||
}
|
||||
|
||||
let punktzahl = 50;
|
||||
|
||||
// Durch match kann ein Wert einer Variable zugeordnet werden, je nachdem, was die Lage ist
|
||||
let note = match punktzahl {
|
||||
0..50 => "Ungenügend",
|
||||
50..67 => "Ausreichend",
|
||||
67..80 => "Befriedigend",
|
||||
80..92 => "Gut",
|
||||
92..101 => "Sehr gut",
|
||||
_ => "Unbekannte Punktzahl",
|
||||
}; // Hier ist ein Semikolon nötig, da es eine Variableninitialisierung ist
|
||||
|
||||
println!("{note}");
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,7 +1,9 @@
|
|||
fn main() {
|
||||
let string: &str = "Das ist ein String.";
|
||||
// Dieser String ist ein String Slice, welcher eine unveränderliche Referenz auf einen bestehenden String ist
|
||||
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}");
|
||||
|
||||
|
|
|
|||
|
|
@ -0,0 +1,20 @@
|
|||
#[allow(dead_code)]
|
||||
#[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 :)")
|
||||
}
|
||||
}
|
||||
|
||||
// Eine Enumeration wird durch enum eingeleitet, danach folgt die Deklarierung der Enum-Konstanten
|
||||
enum Hochschule {
|
||||
Student,
|
||||
Professor,
|
||||
}
|
||||
|
|
@ -1,9 +1,6 @@
|
|||
# Rust Übungsaufagaben:
|
||||
|
||||
## 1. Ownership & Borrowing:
|
||||
|
||||
### Aufgabe 1:
|
||||
|
||||
Erkläre, warum folgender Rust-Code nicht kompiliert:
|
||||
|
||||
```rust
|
||||
|
|
@ -15,11 +12,8 @@ fn main() {
|
|||
}
|
||||
```
|
||||
Ändere den Code so, dass ```s1``` und ```s2``` augegeben werden können.
|
||||
<br> <br>
|
||||
|
||||
|
||||
### Aufgabe 2:
|
||||
|
||||
Warum verbietet Rust folgenden Code?
|
||||
|
||||
```rust
|
||||
|
|
@ -36,7 +30,6 @@ fn main() {
|
|||
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
|
||||
|
|
@ -62,9 +55,7 @@ fn main(){
|
|||
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
|
||||
|
|
@ -79,10 +70,7 @@ fn main() {
|
|||
|
||||
Verwende `Option` oder eine andere Fehlerbehandlung, um sicher auf den Vektor zuzugreifen. Erkläre die Vorteile dieses Ansatzes gegenüber einem Laufzeitfehler ("panic").
|
||||
|
||||
<br>
|
||||
|
||||
### Aufgabe 5:
|
||||
|
||||
Schreibe eine Funktion `parse_number`, die einen String nimmt und ein `Result<i32, String>` zurückgibt:
|
||||
- Bei erfolgreicher Konvertierung: `Ok(zahl)`
|
||||
- Bei Fehler: `Err("Ungültige Eingabe".to_string())`
|
||||
|
|
@ -102,9 +90,7 @@ fn main() {
|
|||
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
|
||||
|
|
@ -123,10 +109,7 @@ fn main() {
|
|||
|
||||
Behebe den Fehler und erkläre, warum die Verwendung von `&str` als Parameter flexibler ist.
|
||||
|
||||
<br>
|
||||
|
||||
### Aufgabe 7:
|
||||
|
||||
Was ist der Unterschied zwischen folgenden zwei Funktionen? Welche ist besser und warum?
|
||||
|
||||
```rust
|
||||
|
|
@ -144,9 +127,7 @@ fn create_greeting_2(name: &str) -> String {
|
|||
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
|
||||
|
|
@ -168,11 +149,8 @@ Implementiere den `Flaeche` Trait für beide Structs. Schreibe dann eine Funktio
|
|||
|
||||
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
|
||||
|
|
@ -202,9 +180,7 @@ fn main() {
|
|||
Erkläre die Rolle von `mut`, `&mut` und `*`.
|
||||
|
||||
## 7. Lifetimes:
|
||||
|
||||
### Aufgabe 10:
|
||||
|
||||
Warum kompiliert folgender Code nicht und wie behebt man das Problem?
|
||||
|
||||
```rust
|
||||
|
|
@ -230,10 +206,8 @@ fn main() {
|
|||
Erkläre, was Lifetimes sind und warum Rust sie braucht. Behebe den Code mit korrekten Lifetime-Annotationen.
|
||||
|
||||
|
||||
## 9. Error Handling und Panic:
|
||||
|
||||
## 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:
|
||||
|
|
@ -254,13 +228,3 @@ fn main() {
|
|||
```
|
||||
|
||||
Erkläre, warum `Result` sicherer ist als ein `panic!` in einer Library-Funktion.
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
|
|
|||
33
README.md
33
README.md
|
|
@ -2,20 +2,24 @@
|
|||
In diesem Repo sind alle Unterlagen für die Präsentation der Programmiersprache Rust
|
||||
Das Repo beinhaltet:
|
||||
- Dockerfile
|
||||
- Basics (TODO)
|
||||
- Basics
|
||||
- Ownership und Borrowing
|
||||
- Pattern Matching und Enumerationen (TODO)
|
||||
- Testing und Debugging (TODO)
|
||||
- Advanced Features von Rust (TODO)
|
||||
- Pattern Matching und Enumerationen (wurde noch nicht gemacht)
|
||||
- Testing und Debugging (wurde noch nicht gemacht)
|
||||
- Advanced Features von Rust
|
||||
Link zur Präsentation: https://docs.google.com/presentation/d/1vkq-cDprBH-5ya1Vvn4xmCyAN0YgbcioXG6CJkVKWDQ/edit?usp=sharing
|
||||
|
||||
# Ablauf
|
||||
1. Warum Rust, (welche Apps), welche Entwicklungsumgebung (ca. 10 Minuten)
|
||||
2. Ökosystem und Einrichtung (Compiler, Cargo) (ca. 5 Minuten)
|
||||
3. Syntax und Basics (ca. 15 Minuten)
|
||||
1. HelloWorld Programm
|
||||
2. Variablen
|
||||
3. Kontrollstrukturen
|
||||
4. Types
|
||||
2. Variablen und Konstanten
|
||||
3. Datentypen und Arithmetik
|
||||
4. Kontrollstrukturen
|
||||
5. Print Makro
|
||||
6. Zusammengesetzte Typen (Compounds, Structs und Enums)
|
||||
7. Funktionen
|
||||
4. Ownership & Borrowing (Live Coding) (ca. 20 Minuten)
|
||||
1. Motivation: Warum Ownership
|
||||
2. Prinzip: Ownership
|
||||
|
|
@ -27,12 +31,13 @@ Link zur Präsentation: https://docs.google.com/presentation/d/1vkq-cDprBH-5ya1V
|
|||
|
||||
# Aufgabenbereich
|
||||
- Semih Uguz (3025014)
|
||||
- B-basics
|
||||
- C-cargo
|
||||
- Basics
|
||||
- Cargo
|
||||
- Präsentieren
|
||||
- Organisation des Repos
|
||||
- Teile von Advanced
|
||||
- Lukas Müller (3017761)
|
||||
- D-ownership
|
||||
- Ownership
|
||||
- Präsentieren
|
||||
- Live Coding
|
||||
- Oliver Stolle (3024383)
|
||||
|
|
@ -42,12 +47,8 @@ Link zur Präsentation: https://docs.google.com/presentation/d/1vkq-cDprBH-5ya1V
|
|||
- Fakten und Anwendungen von Rust
|
||||
- Cheat Sheet
|
||||
- Präsentieren
|
||||
- G-advanced
|
||||
- Concurrency
|
||||
- Vincent Laux (3019006)
|
||||
- Präsentieren
|
||||
- Endpräsentation erstellen
|
||||
- G-advanced
|
||||
- Dominik Stuck (3018438)
|
||||
- Präsentieren
|
||||
- E-enums
|
||||
- F-testing
|
||||
- Dominik Stuck (3018438) (aktuell noch nichts gemacht)
|
||||
|
|
|
|||
Loading…
Reference in New Issue