From 712413da1d3c63f2ff19eae948d24afaac6bfb56 Mon Sep 17 00:00:00 2001
From: Semih <3025014@stud.hs-mannheim.de>
Date: Sat, 30 May 2026 00:22:49 +0200
Subject: [PATCH] =?UTF-8?q?gitignore=20hinzugef=C3=BCgt,=20damit=20Repo=20?=
 =?UTF-8?q?clean=20ist?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 B-basics/1-variablen.rs     |  1 +
 B-basics/2-konstanten.rs    | 11 +++++++----
 B-basics/4-arithmetik.rs    | 37 ++++++++++++++++++++++++++++++++++++-
 B-basics/5-kontrollfluss.rs |  5 ++++-
 B-basics/6-print.rs         |  2 +-
 B-basics/7-compounds.rs     |  2 +-
 B-basics/8-structs.rs       | 10 ++++++++--
 7 files changed, 58 insertions(+), 10 deletions(-)

diff --git a/B-basics/1-variablen.rs b/B-basics/1-variablen.rs
index e256f36..1d0933a 100644
--- a/B-basics/1-variablen.rs
+++ b/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}");
diff --git a/B-basics/2-konstanten.rs b/B-basics/2-konstanten.rs
index 9aaa885..6cd4ff4 100644
--- a/B-basics/2-konstanten.rs
+++ b/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}");
-    static x: i32 = 3;
+    println!("The answer to life, the universe, and everything = {ANTWORT_AUF_ALLES}");
+    // 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
diff --git a/B-basics/4-arithmetik.rs b/B-basics/4-arithmetik.rs
index 9558dc6..c7d4357 100644
--- a/B-basics/4-arithmetik.rs
+++ b/B-basics/4-arithmetik.rs
@@ -1 +1,36 @@
-// Casting auch hier
\ No newline at end of file
+#[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}");
+
+    
+}
diff --git a/B-basics/5-kontrollfluss.rs b/B-basics/5-kontrollfluss.rs
index 774c8a4..99fbbdf 100644
--- a/B-basics/5-kontrollfluss.rs
+++ b/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 
     }
 }
\ No newline at end of file
diff --git a/B-basics/6-print.rs b/B-basics/6-print.rs
index ce439df..74a9867 100644
--- a/B-basics/6-print.rs
+++ b/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);
diff --git a/B-basics/7-compounds.rs b/B-basics/7-compounds.rs
index 4828732..ec83fbe 100644
--- a/B-basics/7-compounds.rs
+++ b/B-basics/7-compounds.rs
@@ -18,4 +18,4 @@ fn main() {
     println!("{}", element);
 
     println!("{}", array.len()); // Länge kann ausgegeben werden
-}
\ No newline at end of file
+}
diff --git a/B-basics/8-structs.rs b/B-basics/8-structs.rs
index b12ca5e..1edaf80 100644
--- a/B-basics/8-structs.rs
+++ b/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);
-}
\ No newline at end of file
+    // {:#?} ist eine Debug Ausgabe wie {:?}, nur ist die Formattierung etwas schöner
+    println!("{:#?}", semih);
+}