gitignore hinzugefügt, damit Repo clean ist

B-basics/1-variablen.rs

@@ -1,4 +1,5 @@
 fn main() {
+    // Variablen werden mit let eingeleitet
     let x = 42; // unveränderbar (final in Java)
                 //x += 1; Das würde nicht funktionieren
     println!("{x}");

B-basics/2-konstanten.rs

@@ -4,7 +4,7 @@ use std::sync::Mutex;
 const ANTWORT_AUF_ALLES: i32 = 42;
 // Const sind echte Konstanten, die nicht verändert werden könne und auch nicht überschattet werden können
 // Dies haben keinen festen Speicherplatz, sondern werden überall eingebettet, wo diese verwendet werden
-// Sie können in jedem Scope definiert werden, auch in Funktionen wie Variablen
+// Es muss explizit geschrieben werden, welchen Typ die Konstante hat
 
 static mut PRAESENTIERER: &str = "Semih";
 // Bei static ist es anders, diese existieren genau einmal im Speicher und haben somit eine feste Speicheradresse
@@ -13,8 +13,12 @@ static mut PRAESENTIERER: &str = "Semih";
 static COUNTER: Mutex<u32> = Mutex::new(0); // Nun ist es sicher dank Mutex
 
 fn main() {
-    println!("x = {ANTWORT_AUF_ALLES}");
+    println!("The answer to life, the universe, and everything = {ANTWORT_AUF_ALLES}");
-    static x: i32 = 3;
+    // Konstanten können auch in Funktionen deklariert werden
+    const WITZIGES: i8 = 24;
+    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 {
@@ -23,7 +27,6 @@ fn main() {
         println!("Der nächste Präsentierer ist: {PRAESENTIERER}");
     }
 
-
     // Das hier in Advanced
     {
         // Hier erstellen wir eine veränderliche Variable, die wir dannn locken, dann unwrappen, und dann um eins erhöhen können

B-basics/4-arithmetik.rs

@@ -1 +1,36 @@
+#[allow(non_snake_case)] // Dafür da, dass moduloInKurz ohne Meckern geschrieben werden kann
+#[allow(overflowing_literals)] // Für Overflow Spaß
+
 // Casting auch hier
+fn main() {
+    // Grundrechenarten sind alle wie in anderen Sprachen, nichts spannendes
+    let summe: i32 = 12 + 23;
+    let differenz: i32 = summe - 10;
+    let produkt: i32 = differenz * summe;
+    let quotient: i32 = produkt / differenz;
+    let modulo: i32 = quotient % 2;
+
+    println!("{summe}");
+    println!("{differenz}");
+    println!("{produkt}");
+    println!("{quotient}");
+    println!("{modulo}");
+
+    // modulo benötigt jetzt keine 32 Bits, man kann es auch in i8 packen
+    let moduloInKurz = modulo as i8;
+    println!("{moduloInKurz}");
+
+    // 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 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}");
+
+    
+}

B-basics/5-kontrollfluss.rs

@@ -10,12 +10,15 @@ fn main() {
         println!("x ist positiv");
     }
 
+    // While Schleifen wie in Java, nur ohne Klammen
+    // Klammern dürfen dabei stehen, das würde aber ein Warning ausgeben
     while x < 10 {
         println!("x ist kleiner als 10");
         x += 1;
     }
 
-    for i in 1..100 {
+    // 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 
     }
 }

B-basics/6-print.rs

@@ -27,7 +27,7 @@ fn main() {
 
     // Um Arrays und Structs (kommt noch) auszugeben, kann der Doppelpunkt auch verwendet werden
     let array = [1, 2, 3, 4];
-    println!("{:?}", array); // Das ? gibt an NICHT FERTIG
+    println!("{:?}", array); // Das ? gibt an, dass es eine Debug Ausgabe ist
 
     // Zahlen können in unterschiednlichen Zahlensystemen ausgegeben werden
     println!("x in Binär = {:b}", x);

B-basics/8-structs.rs

@@ -1,4 +1,9 @@
+#[allow(dead_code)]
+// Diese Präprozessoranweisung gibt an, dass toter Code, der nicht benutzt wird, erlaubt wird
+// Toter Code ist zwar auch so erlaubt, aber es würde zu einer Warnung kommen
+
 // Structs in Rust sind sehr nah an den Structs in Go
+#[derive(Debug)] // Diese Anweisung gibt an, dass Person das Debug-Trait implementiert, um Debug Ausgaben mit {:?} erzeugen zu können
 struct Person {
     name: String,
     alter: u8,
@@ -10,5 +15,6 @@ fn main() {
         alter: 21,
     };
 
-    println!("Name: {}\nAlter: {}", semih.name, semih.alter);
+    // {:#?} ist eine Debug Ausgabe wie {:?}, nur ist die Formattierung etwas schöner
+    println!("{:#?}", semih);
 }