Noch mehr Zeug hinzugefügt

B-basics/2-konstanten.rs

@@ -0,0 +1,41 @@
+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
+// 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
+
+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!("x = {ANTWORT_AUF_ALLES}");
+    static x: i32 = 3;
+
+    // Da static mut unsafe ist, können sie nur in solchen unsafe Blöcken verändert und gelesen werden, anders nicht
+    unsafe {
+        println!("Aktueller Präsentierer ist: {PRAESENTIERER}");
+        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/4-arithmetik.rs

@@ -0,0 +1 @@
+// Casting auch hier

B-basics/4-print.rs

@@ -1,23 +0,0 @@
-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!("{}", "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!("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);
-
-    let semih = "Semih";
-    let rust = "Rust";
-
-    // Es kann angegeben werden, welche Variable in das jeweilige Escape geschrieben werden soll
-    println!("{1} zeigt euch die Programmiersprache {0}!", rust, semih);
-
-    let pi = 3.14159265359;
-
-    println!("π ≈ {:.3}", pi);
-}

B-basics/5-kontrollfluss.rs

@@ -0,0 +1,21 @@
+fn main() {
+    let mut x = 0;
+
+    // If Bedingungen sind sehr ähnlich zu anderen Sprachen
+    if x == 0 {
+        println!("x ist Null");
+    } else if x < 0 {
+        println!("x ist negativ");
+    } else {
+        println!("x ist positiv");
+    }
+
+    while x < 10 {
+        println!("x ist kleiner als 10");
+        x += 1;
+    }
+
+    for i in 1..100 {
+        if i % 2 
+    }
+}

B-basics/6-print.rs

@@ -0,0 +1,39 @@
+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!(
+        "{}",
+        "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!(
+        "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);
+
+    let semih = "Semih";
+    let rust = "Rust";
+
+    // Es kann angegeben werden, welche Variable in das jeweilige Escape geschrieben werden soll
+    println!("{1} zeigt euch die Programmiersprache {0}!", rust, semih);
+
+    let pi = 3.14159265359;
+    println!("π ≈ {:.3}", pi); // Floating Point Zahlen können gerundet werden
+
+    // 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
+
+    // Zahlen können in unterschiednlichen Zahlensystemen ausgegeben werden
+    println!("x in Binär = {:b}", x);
+    println!("x in Oktal = {:o}", x);
+    println!("x in Hex = {:x}", x);
+
+    // Neben print! und println! gibt es auch eprint! und eprintln! für Ausgabe in stderr
+    eprintln!("Festplatte explodiert!");
+}

B-basics/7-compounds.rs

@@ -10,7 +10,7 @@ fn main() {
     println!("{}, {}, {}", a, b, c);
 
     let array: [&str; 5] = ["Das", " ist", " ein", " Array", "."]; // Es wird explizit geschrieben, welche Größe es hat
-    println!("{:?}", array); // Das wird auch später erklärt
+    println!("{:?}", array);
 
     let array = [1, 2, 3, 4, 5, 6]; // Größe wird dynamisch bestimmt
     println!("{:?}", array);

B-basics/8-structs.rs

@@ -0,0 +1,14 @@
+// Structs in Rust sind sehr nah an den Structs in Go
+struct Person {
+    name: String,
+    alter: u8,
+}
+
+fn main() {
+    let semih = Person {
+        name: "Semih".to_string(),
+        alter: 21,
+    };
+
+    println!("Name: {}\nAlter: {}", semih.name, semih.alter);
+}

B-basics/9-funktionen.rs

@@ -0,0 +1 @@
+// Funktion ohne Rückgabewert returnt Unit (leeres Tupel)