Kleine Veränderungen

B-basics/1-variablen.rs

@@ -25,7 +25,4 @@ fn main() {
 
     let x = "Typwechsel ist erlaubt!";
     println!("{x}");
-
-    const KONSTANTE: i32 = 42; // Gar nicht mehr veränderbar (auch nicht durch Shadowing)
-    println!("{KONSTANTE}");
 }

B-basics/2-konstanten.rs

@@ -1,5 +1,3 @@
-use std::sync::Mutex;
-
 // Globale Konstanten, können außerhalb von Funktionen deklariert werden
 const ANTWORT_AUF_ALLES: i32 = 42;
 // Const sind echte Konstanten, die nicht verändert werden könne und auch nicht überschattet werden können
@@ -10,7 +8,6 @@ static mut PRAESENTIERER: &str = "Semih";
 // Bei static ist es anders, diese existieren genau einmal im Speicher und haben somit eine feste Speicheradresse
 // Können mit mut versehen werden, diese können dann verändert werden in unsafe Blöcken
 // Dies sollte eher vermieden werden, um veränderbare static Konstanten zu erzeugen sollten Mutex verwendet werden
-static COUNTER: Mutex<u32> = Mutex::new(0); // Nun ist es sicher dank Mutex
 
 fn main() {
     println!("The answer to life, the universe, and everything = {ANTWORT_AUF_ALLES}");
@@ -26,19 +23,4 @@ fn main() {
         PRAESENTIERER = "Lukas";
         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
-        // Für die Basics ist das zu komplex zum erklären, wir nehmen das mal so hin
-        // Man muss es in dem Fall nicht nochmal unlocken, dass geschieht beim Verlassen des Blocks automatisch
-        let mut c = COUNTER.lock().unwrap();
-        println!("{c}");
-        *c += 1;
-    }
-
-    {
-        let c = COUNTER.lock().unwrap();
-        println!("{c}");
-    }
 }

B-basics/6-print.rs

@@ -1,18 +1,12 @@
 fn main() {
     // print ist ein Makro welches Text an die Standardausgabe (stdout) sendet
     // println ist ein ähnliches Makro, welches einen Zeilenumbruch anhängt
-
     println!("Hier geschieht eine Textausgabe in die Standardausgabe");
-    println!(
+    println!("{}", "Die geschweiften Klammern sind quasi die Escape Zeichen der printf() Funktion aus C");
-        "{}",
-        "Die geschweiften Klammern sind quasi die Escape Zeichen der printf() Funktion aus C"
-    );
 
     let x = 42;
     // Wenn der Name der Variable in die geschweiften Klammern geschrieben wird, kann diese auch ausgegeben werden
-    println!(
+    println!("Variablen können deklariert und somit in die Standardausgabe geschrieben werden: x = {x}");
-        "Variablen können deklariert und somit in die Standardausgabe geschrieben werden: x = {x}"
-    );
     // Hier sieht man die printf() Mechanik aus C
     println!("Variable außerhalb geschrieben: x = {}", x);
 

B-basics/9-funktionen.rs

@@ -11,7 +11,7 @@ fn main() {
     println!("{:?}", r.flaeche());
 }
 
-// Das ist eine Funktion, die ein Boolean zurück gibt, Parameter können in die Klammern geschrieben werden
+// Das ist eine Funktion, die ein Boolean 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
@@ -26,7 +26,7 @@ fn odd(a: i32) -> () {
     }
 }
 
-// Man kann das -> auch weglassen, dann wird automatisch die Unit zurück gegeben 
+// Man kann das -> auch weglassen, dann wird automatisch die Unit zurückgegeben 
 fn random_ausgabe() {
     println!("Funktion ohne Parameter und \"ohne\" Rückgabewert");
 }
@@ -56,4 +56,4 @@ impl Rechteck {
         self.hoehe *= s;
         self.breite *= s;
     }
-}
+}

G-advanced/static-mutex.rs

@@ -0,0 +1,17 @@
+use std::sync::Mutex;
+static COUNTER: Mutex<u32> = Mutex::new(0); // Nun ist es sicher dank Mutex
+
+fn main() {
+    {
+        // Hier erstellen wir eine veränderliche Variable, die wir dannn locken, dann unwrappen, und dann um eins erhöhen können
+        // Man muss es in dem Fall nicht nochmal unlocken, dass geschieht beim Verlassen des Blocks automatisch
+        let mut c = COUNTER.lock().unwrap();
+        println!("{c}");
+        *c += 1;
+    }
+
+    {
+        let c = COUNTER.lock().unwrap();
+        println!("{c}");
+    }
+}