From 9d189dbac216b337afe260079d9a47700547c4fc Mon Sep 17 00:00:00 2001
From: Semih <3025014@stud.hs-mannheim.de>
Date: Fri, 29 May 2026 15:59:49 +0200
Subject: [PATCH] =?UTF-8?q?Noch=20mehr=20Zeug=20hinzugef=C3=BCgt?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 B-basics/2-konstanten.rs                      | 41 +++++++++++++++++++
 B-basics/{2-datentypen.rs => 3-datentypen.rs} |  0
 B-basics/4-arithmetik.rs                      |  1 +
 B-basics/4-print.rs                           | 23 -----------
 B-basics/5-kontrollfluss.rs                   | 21 ++++++++++
 B-basics/6-print.rs                           | 39 ++++++++++++++++++
 B-basics/{3-compounds.rs => 7-compounds.rs}   |  2 +-
 B-basics/8-structs.rs                         | 14 +++++++
 B-basics/9-funktionen.rs                      |  1 +
 9 files changed, 118 insertions(+), 24 deletions(-)
 create mode 100644 B-basics/2-konstanten.rs
 rename B-basics/{2-datentypen.rs => 3-datentypen.rs} (100%)
 create mode 100644 B-basics/4-arithmetik.rs
 delete mode 100644 B-basics/4-print.rs
 create mode 100644 B-basics/5-kontrollfluss.rs
 create mode 100644 B-basics/6-print.rs
 rename B-basics/{3-compounds.rs => 7-compounds.rs} (91%)
 create mode 100644 B-basics/8-structs.rs
 create mode 100644 B-basics/9-funktionen.rs

diff --git a/B-basics/2-konstanten.rs b/B-basics/2-konstanten.rs
new file mode 100644
index 0000000..9aaa885
--- /dev/null
+++ b/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}");
+    }
+}
diff --git a/B-basics/2-datentypen.rs b/B-basics/3-datentypen.rs
similarity index 100%
rename from B-basics/2-datentypen.rs
rename to B-basics/3-datentypen.rs
diff --git a/B-basics/4-arithmetik.rs b/B-basics/4-arithmetik.rs
new file mode 100644
index 0000000..9558dc6
--- /dev/null
+++ b/B-basics/4-arithmetik.rs
@@ -0,0 +1 @@
+// Casting auch hier
\ No newline at end of file
diff --git a/B-basics/4-print.rs b/B-basics/4-print.rs
deleted file mode 100644
index 97eda56..0000000
--- a/B-basics/4-print.rs
+++ /dev/null
@@ -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);
-}
\ No newline at end of file
diff --git a/B-basics/5-kontrollfluss.rs b/B-basics/5-kontrollfluss.rs
new file mode 100644
index 0000000..774c8a4
--- /dev/null
+++ b/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 
+    }
+}
\ No newline at end of file
diff --git a/B-basics/6-print.rs b/B-basics/6-print.rs
new file mode 100644
index 0000000..ce439df
--- /dev/null
+++ b/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!");
+}
diff --git a/B-basics/3-compounds.rs b/B-basics/7-compounds.rs
similarity index 91%
rename from B-basics/3-compounds.rs
rename to B-basics/7-compounds.rs
index a655cef..4828732 100644
--- a/B-basics/3-compounds.rs
+++ b/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);
diff --git a/B-basics/8-structs.rs b/B-basics/8-structs.rs
new file mode 100644
index 0000000..b12ca5e
--- /dev/null
+++ b/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);
+}
\ No newline at end of file
diff --git a/B-basics/9-funktionen.rs b/B-basics/9-funktionen.rs
new file mode 100644
index 0000000..c2e8fd4
--- /dev/null
+++ b/B-basics/9-funktionen.rs
@@ -0,0 +1 @@
+// Funktion ohne Rückgabewert returnt Unit (leeres Tupel)
\ No newline at end of file