Add solution for example in L01

Author: SebastianZug

.gitignore

@@ -9,3 +9,6 @@ output/
 bin/
 obj/
 .vscode/
+
+code/01_Software/improved
+code/01_Software/withBugs

01_Software.md

@@ -494,6 +494,8 @@ Das Programm schließt zwei Bugs ein:
 1. Der Vergleich schließt die Werte mit dem Index 0 aus da die Bedingung `i=2` lautet, aber die Indizes von 0 bis 9 gehen. Das führt zu einem unvollständigen Sortieren.
 2. `l++` in Zeile 14 bewirkt das `l` hinter das Ende des Arrays zeigt. Damit sind Zugriffe auf `a[j]` wegen `j=l` in Zeile 25 undefiniert und können zu einem Absturz führen.
 
+Eine überarbeitete studentische Lösung (Nico Seidler, SoSe 2026) findet sich unter [code/01_Software/](https://github.com/TUBAF-IfI-LiaScript/VL_Softwareentwicklung/tree/master/code/01_Software) — inklusive einer [README](https://github.com/TUBAF-IfI-LiaScript/VL_Softwareentwicklung/blob/master/code/01_Software/README.md), die Stärken und offene Diskussionspunkte gegenüberstellt.
+
 *******************************************************************************
 
 ## Herausforderungen

code/01_Software/README.md

@@ -0,0 +1,65 @@
+# Codebeispiel "AllesFalsch" – Bugs und überarbeitete Lösung
+
+Dieser Ordner begleitet den Abschnitt *Qualitätsmängel erkennen* aus [01_Software.md](../../01_Software.md).
+
+Die Lösung hat Nico Seidler (SoSe 2026) beigesteuert. Die überarbeitete Version korrigiert die beiden echten Bugs der Ursprungsfassung, beseitigt einige Qualitätsmängel (z. B. fehlende Fehlerprüfungen, ungenutzte Header) und verbessert die Wartbarkeit durch bessere Strukturierung und sprechende Bezeichner. Dennoch bleiben einige Schwächen (z. B. algorithmische Komplexität, Endlosschleife bei Fehleingaben) bestehen, um Diskussionsanlässe zu bieten.
+
+| Datei                        | Inhalt                                                                 |
+| ---------------------------- | ---------------------------------------------------------------------- |
+| [withBugs.c](withBugs.c)     | Ursprungsfassung mit zahlreichen Qualitätsmängeln und zwei echten Bugs |
+| [improved.c](improved.c)     | Überarbeitete Lösung (studentischer Beitrag, SoSe 2026)                |
+| [numbers.txt](numbers.txt)   | Beispiel-Eingabedatei                                                  |
+
+## Übersetzen und Ausführen
+
+```bash
+gcc -Wall -Wextra -O2 improved.c -o improved
+./improved
+# Eingabe des Pfads, z. B.: numbers.txt
+```
+
+## Stärken der überarbeiteten Lösung
+
+Die Lösung adressiert systematisch die in der ISO-25010-Tabelle aufgelisteten Qualitätsmerkmale:
+
+- **Funktionale Eignung** — Beide Bugs des Originals sind korrigiert:
+  - äußere Sortierschleife startet bei `i = 0` (vorher fälschlich `i = 2` → Element 0 und 1 wurden nicht einbezogen),
+  - innere Schleife läuft bis `j < n - i - 1` (vorher `j = l` → Zugriff hinter das Array-Ende).
+- **Zuverlässigkeit** — `fopen` wird auf `NULL` geprüft, `fclose` und `free` werden konsequent aufgerufen, auch auf den Fehlerpfaden (z. B. `realloc`-Fail).
+- **Leistungseffizienz (partiell)** — Sortierung *in-place* über Zeigerübergabe, keine Array-Kopie.
+- **Wartbarkeit** — BubbleSort ist in eine eigene Funktion mit Doxygen-Kopf ausgelagert; sprechende Bezeichner (`pfad`, `daten`, `kapazitaet`, `anzahl`).
+- **Sicherheit** — `scanf("%255s", …)` mit expliziter Längenbegrenzung → kein Buffer Overflow beim Einlesen des Pfads.
+- **Flexibilität** — Dateipfad wird zur Laufzeit abgefragt, Datenarray wächst dynamisch über `realloc`.
+- **Robuster `realloc`-Umgang** — Rückgabewert wird in einem Zwischenpointer (`optimiert`) aufgefangen, damit `daten` bei Allokationsfehler nicht verloren geht.
+
+## Offene Punkte / Diskussionsanlässe
+
+Nicht alle Schwächen des Originals sind vollständig behoben. Die folgenden Punkte eignen sich gut für die Plenumsdiskussion:
+
+1. **Endlosschleife bei wiederholter Fehleingabe**
+   Die `while (datei == NULL)`-Schleife besitzt kein Abbruchkriterium. Bei permanent falschen Eingaben läuft das Programm unbegrenzt.
+   *Verbesserung:* Maximale Anzahl Versuche oder Abbruch bei `EOF`.
+
+2. **Algorithmische Komplexität weiterhin O(n²)**
+   Der Mangel "quadratischer Aufwand der Sortierung" aus der Qualitätstabelle wird nicht behoben. 
+   *Verbesserung:* `swapped`-Flag für Early-Exit bei sortierten Eingaben, oder Verwendung von `qsort` aus `<stdlib.h>`.
+
+3. **Magic Numbers**
+   Die Werte `256` (Pfadlänge) und `10` (Startkapazität) stehen im Code ohne Benennung.
+   *Verbesserung:* `#define` bzw. `PATH_MAX` aus `<limits.h>`.
+
+4. **Keine Validierung der Datei-Inhalte**
+   `fscanf` bricht beim ersten Nicht-Integer still ab; nachfolgende gültige Zahlen werden ignoriert, ohne Warnung.
+   *Verbesserung:* Ursache des Abbruchs prüfen (`feof` vs. Parse-Fehler) und melden.
+
+5. **Sonderfall leere Datei**
+   Bei `anzahl == 0` wird trotzdem "Sortierte Ergebnisse:" ausgegeben.
+   *Verbesserung:* explizite Meldung "Keine Daten eingelesen".
+
+6. **Pfade mit Leerzeichen**
+   `scanf("%255s", …)` liest nur bis zum ersten Whitespace.
+   *Verbesserung:* `fgets` + Newline-Trimming.
+
+## Bezug zur Vorlesung
+
+Die Lösung zeigt exemplarisch, dass *Bug-Fix* und *Qualitätsverbesserung* zwei unterschiedliche Dimensionen sind: Die funktionalen Fehler sind behoben, einige nicht-funktionale Mängel (insbesondere Leistungseffizienz und vollständige Eingabevalidierung) bleiben jedoch bestehen. Genau diese Trennung ist ein zentrales Motiv des Abschnitts.

code/01_Software/improved.c

@@ -0,0 +1,96 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+/**
+ * @brief BubbleSort-Algorithmus als eigene Funktion (Prozedur) -> Wartbarkeit
+ * Ausnutzen von Seiteneffekten (Zeigeruebergabe -> Call by Reference) zum Sortieren des originalen Arrays,
+ * kein Anfertigen einer Array-Kopie notwendig -> Effizienz
+ * @param arr zu sortierendes Integer-Array
+ * @param n   Laenge des Arrays (Anz. Elemente im Array)
+ */
+void bubbleSort(int arr[], int n) {
+    int i, j, temp;
+    
+    // auessere Schleife -> bestimmt, wie oft das Array durchlaufen wird
+    for (i = 0; i < n - 1; i++) {
+        // innere Schleife zum Vergleich benachbarter Elemente (j und j + 1)
+        /* 'n - i - 1' sorgt dafuer, dass bereits sortierte Elemente 
+            am Ende des Arrays nicht erneut geprueft werden. -> Effizienz */
+        for (j = 0; j < n - i - 1; j++) {
+            
+            if (arr[j] > arr[j + 1]) {
+                // Tauschvorgang mit temp-Variable
+                temp = arr[j];
+                arr[j] = arr[j + 1];
+                arr[j + 1] = temp;
+            }
+        }
+    }
+}
+
+int main() {
+    char pfad[256];
+    int *daten = NULL;
+    int kapazitaet = 10;
+    int anzahl = 0;
+    int wert;
+    FILE *datei = NULL;
+
+    // flexibler Pfad statt hart gecodeter Standardpfad zur Standard-Datei
+    // Fehlerbehandlung bei falscher Eingabe
+    while (datei == NULL) {
+        printf("Bitte den Pfad zur Datei eingeben (ohne Leerzeichen): ");
+        if (scanf("%255s", pfad) != 1) return 1;
+
+        // Oeffnen der Datei inkl. Fehlerbehandlung
+        datei = fopen(pfad, "r");
+        if (datei == NULL) {
+            printf("Datei nicht gefunden! Bitte erneut versuchen.\n");
+        }
+    }
+
+    // Allokieren dynamischen Speichers, damit Arraygroesse erst zur Laufzeit festgelegt wird 
+    daten = malloc(kapazitaet * sizeof(int));
+    if (daten == NULL) {
+        fclose(datei);
+        return 1;
+    }
+
+    // Einlesen der Daten
+    while (fscanf(datei, "%d", &wert) == 1) {
+        if (anzahl >= kapazitaet) {
+            kapazitaet *= 2;
+            // realloc fuer dynamische Speicherallokierung zur Laufzeit, ebenso Behandlung 
+            // von Platzmangel an zusammenhaengendem Speicherbereich auf dem Heap
+            int *optimiert = realloc(daten, kapazitaet * sizeof(int));
+            
+            if (optimiert == NULL) {
+                free(daten);
+                fclose(datei);
+                return 1;
+            }
+            daten = optimiert;
+        }
+        daten[anzahl++] = wert;
+    }
+
+    // Datei am Ende schliessen
+    fclose(datei);
+
+    // Aufruf der Bubblesort-Funktion
+    if (anzahl > 1) {
+        bubbleSort(daten, anzahl);
+    }
+
+    // Ausgabe der sortierten Liste
+    printf("\nSortierte Ergebnisse:\n");
+    for (int i = 0; i < anzahl; i++) {
+        printf("%d ", daten[i]);
+    }
+    printf("\nFertig! (%d Eintraege verarbeitet)\n", anzahl);
+
+    // Freigeben des vorher genutzten Heapspeichers
+    free(daten);
+    // Programm erfolgreich beendet
+    return 0;
+}