diff --git a/B-basics/4-arithmetik.rs b/B-basics/4-arithmetik.rs index c7d4357..ac9add1 100644 --- a/B-basics/4-arithmetik.rs +++ b/B-basics/4-arithmetik.rs @@ -10,27 +10,31 @@ fn main() { let quotient: i32 = produkt / differenz; let modulo: i32 = quotient % 2; - println!("{summe}"); - println!("{differenz}"); - println!("{produkt}"); - println!("{quotient}"); - println!("{modulo}"); - + // Casting durch explizites angeben des Typs, implizit ist es nicht möglich // 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}"); - - } diff --git a/B-basics/5-kontrollfluss.rs b/B-basics/5-kontrollfluss.rs index 99fbbdf..38a1396 100644 --- a/B-basics/5-kontrollfluss.rs +++ b/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); } -} \ No newline at end of file + + // Loop läuft solange, bis ein break irgendwo erscheint, oder endlos + loop { + println!("Endlosschleifeeeee..."); + break; // nicht mehr endlos + } +} diff --git a/B-basics/8-structs.rs b/B-basics/8-structs.rs index 1edaf80..81ef8a7 100644 --- a/B-basics/8-structs.rs +++ b/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 { diff --git a/B-basics/9-funktionen.rs b/B-basics/9-funktionen.rs index c2e8fd4..33f3765 100644 --- a/B-basics/9-funktionen.rs +++ b/B-basics/9-funktionen.rs @@ -1 +1,59 @@ -// Funktion ohne Rückgabewert returnt Unit (leeres Tupel) \ No newline at end of file +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; + } +} \ No newline at end of file diff --git a/README.md b/README.md index bd5ccf1..043c1a9 100644 --- a/README.md +++ b/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 | -| ------- | ----------------------------------- | -| Lukas | Präsentieren, 4 | -| Semih | Präsentieren, 3 | -| Dominik | Präsentieren, 5, 6 | -| Vincent | Präsentieren und 8, Endpräsentation | -| Oliver | Hausaufgabe, DevContainer | -| Julian | Einleitung & 7 | - -# Notizen -- Cheat Sheet erstellen -- Tests für die Hausaufgabe erstellen +- Semih Uguz (3025014) + - B-basics + - C-cargo + - Präsentieren + - Organisation des Repos +- Lukas Müller (3017761) + - D-ownership + - Präsentieren + - Live Coding +- Oliver Stolle (3024383) + - Dev Container + - 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