update sp1 content for first lesson

src/sp1/hausaufgaben.md

@@ -0,0 +1,34 @@
+---
+title: "How-To: Hausaufgaben"
+layout: "blog-post.njk"
+date: 2025-05-05
+---
+Der Ablauf der Bearbeitung einer Aufgabe am Beispiel "Aufgabe 0 - epoche"
+
+1. Aufgaben-Repository erstellen (muss im cip ausgeführt werden)
+```sh
+/proj/i4sp1/bin/mkrepo epoche
+```
+Das Repo ist dann im [Gitlab](https://gitlab.cs.fau.de/) der FAU zu finden zu funden 
+
+2. Das Repo clonen (lokal herunterladen). Die URL findet ihr unter dem blauen "Code" button auf dem Repo in Gitlab.
+```sh
+git clone [REPO-URL]
+```
+
+3. Lokale Änderungen durchführen
+
+4. Die Änderungen und neuen Dateien dem lokalen commiten
+```sh
+git add . # Änderungen in den Staging bereich schieben
+git commit -m "[COMMIT_MESSAGE]" # Die Änderungen mit einem deskriptiven kommentar zu einem commit zusammenfasssen
+```
+
+5. Alle commmits zu dem FAU Gitlab pushen (**SEHR WICHTIG**). Es kann nur bewertet werden, was vor der deadline gepushed wurde
+```sh
+git push
+```
+möglicherweise funktioniert das nicht auf anhieb und es muss einmal folgender command ausgeführt werden:
+```sh
+git push --set-upstream origin main
+```

src/sp1/index.md

@@ -4,14 +4,15 @@ layout: blog-page.njk
 page_for: "sp1-lesson"
 ---
 ## Meine Übungen
-- Tafelübung (T02) Montags 14:15 - 15:45 im [Seminarraum 0.031-113](https://www.campo.fau.de:443/qisserver/pages/startFlow.xhtml?_flowId=showRoomDetail-flow&roomId=788&roomType=3&context=showRoomDetail&navigationPosition=organisation,searchroom)
+- Tafelübung (T02) Montags 14:15 - 15:45 im [Seminarraum 0.031-113 (Aquarium)](https://www.campo.fau.de:443/qisserver/pages/startFlow.xhtml?_flowId=showRoomDetail-flow&roomId=788&roomType=3&context=showRoomDetail&navigationPosition=organisation,searchroom)
 - Rechnerübung Donnerstags 16:15 - 18:45 im [CIP1](https://www.campo.fau.de/qisserver/pages/startFlow.xhtml?_flowId=showRoomDetail-flow&roomId=3349&roomType=3&context=showRoomDetail&navigationPosition=organisation,searchroom)
 
 ## Wichtige Infos
+- <a href="./hausaufgaben">How-To: Hausaufgaben</a>
 - Unter `/proj/i4sp1/bin/` im CIP finden sich nützliche SP1-related Programme und scripts, wie
     - `mkrepo` zum Aufgaben-Repo erstellen
     - `deadline` zum Abgabetermine nachschauen
-- Vorgegebene Compiler-Flags: `-std=c11 -pedantic -D_XOPEN_SOURCE=700 -Wall -Werror -fsanitize=undefined -fno-sanitize-recover -g`
+- Vorgegebene Compiler-Flags: `-std=c11` `-pedantic` `-D_XOPEN_SOURCE=700` `-Wall` `-Werror` `-fsanitize=undefined` `-fno-sanitize-recover` `-g`
 
 ## Wichtige Links
 - [Aufgaben](https://sys.cs.fau.de/lehre/ss25/sp1/uebung#aufgaben)
@@ -33,8 +34,13 @@ page_for: "sp1-lesson"
 - Mail an mich: <a href="mailto:nova.ruff@fau.de" class="link">nova.ruff@fau.de</a>
 - [SP-FAQ](https://sys.cs.fau.de/lehre/ss25/sp1/faq)
 
-
-## Weitere Links
+## Andere Tutoren
 - [SP1 Website](https://sys.cs.fau.de/lehre/ss25/sp1)
+- [Lukas (T03)](https://wwwcip.cs.fau.de/~uk16isyq/)
 - [Julian (T08)](https://jzbor.de/tut/sp1/)
+- [Stefan (T09)](https://wwwcip.cs.fau.de/~ok73ozus/sp)
+- [Luca (T11)](https://wwwcip.cs.fau.de/~am99ihig/sp)
 - [Philip (ehemalig)](https://wwwcip.cs.fau.de/~oj14ozun/sp1/)
+
+## Hilfreiche Links
+- [cdecl.org](https://cdecl.org/) um zu entziffern, was bei Pointern passiert

src/sp1/ub1.md

@@ -7,6 +7,8 @@ date: 2025-05-04
 ## Manual-Pages
 Mit dem Programm `man` kann die Dokumentation von verschiedenen Bibliotheksfunktionen nachgelesen werden: `man 3p printf`
 
+Oft findet ihr die schreibweise `time(3p)`, d.h. es wird auf die manpage von time aus der section 3p verwiesen: `man 3p time`
+
 ## Workflow mit git
 - `git clone [URL]` - Remote Repo lokal herunterladen
 - `git pull` - Neuester Stand eines Repos herunterladen
@@ -16,23 +18,83 @@ Mit dem Programm `man` kann die Dokumentation von verschiedenen Bibliotheksfunkt
 - `git commit -m "[COMMMIT_MESSAGE]"` - Änderungen zu dem Repo committen
 - `git push` - Neue Commits an das remote Repo kommunizieren (**wichtig zur Übungsabgabe**)
 
-## Beispiel Program aus der Präsenzübung
+## Die C Programmiersprache
+- Die "main" funktion in C bekommt immer 2 argumente:
+  - `int argc`: enthält 1 + die Anzahl der Argumente, die dem Program gegeben wurden
+  - `char *argv[]`: ein array von char-pointern (also ein char-pointer-pointer)
+- Das ende von char-arrays (string) wird mit dem Zeichen `'\0'` gekennzeichnet
+- Array-Zugriff: `arr[1]` ist gleichbedeutend mit `*(arr + 1)`
+- Struct-Zugriff: `myStruct->value` ist gleichbedeutend mit `(*myStruct).value`
+- <a href="{{ "/assets/Pointer-Diagramm.pdf" | url }}">Nützliches Pointer Diagramm</a>
+
+## Fehlerbehandlung (wichtig)
+Funktionen können in C fehlschlagen und fehler müssen **immer** abgefangen und behandelt werden (außer in einer bereits laufenden Fehlerbehandlung).
+
+Was der Rückgabewert einer Funktion ist, wenn sie fehlschlägt, steht in dem "RETURN VALUE" Abschnitt der zugehörigen manpage.
+z.B. steht in malloc(3p), dass im Fehlerfall ein "null pointer" returned wird; Wir müssen uns also nach jedem malloc-Aufruf versichern, dass der Rückgabewert nicht ein null pointer war:
 ```c
-#include <stdio.h>
-#include <string.h>
+#include <stdlib.h>
 
 int main(int argc, char *argv[]) {
-  // using strlen()
-  for (int i = 1; i < argc; i++) {
-    char *curr_arg = argv[i];
-    for (int l = 0; l < strlen(curr_arg); l++) {
-      printf("%c\n", curr_arg[l]);
-    }
+  // wir wollen 5 ints abspeichern
+  int *p = malloc(sizeof(int) * 5);
+  if (p == NULL) {
+    // es gab einen fehler
+    return -1;
+  }
+  // kein fehler -> es kann weitergemacht werden ...
+}
+```
+
+## malloc und free
+Wichtig ist, dass mit `malloc` allokierter speicher auch wieder manuell mit der Funktion `free()` freigegeben werden **muss** (`free()` kann nicht fehlschlagen und benötigt so auch keine Fehlerbehandlung):
+```c
+#include <stdlib.h>
+
+int main(int argc, char *argv[]) {
+  int *p = malloc(sizeof(int) * 5);
+  if (p == NULL) {
+    return -1;
   }
 
-  // alternative
+  // ... do something with p ...
+
+  free(p);
+}
+```
+
+## Beispiel Programme aus der Präsenzübung
+### Alle dem Program gegebenen Argumente drucken
+```c
+#include <stdio.h>
+
+int main(int argc, char *argv[]) {
+  // iterate over arguments passed to program
   for (int i = 1; i < argc; i++) {
+    // get reference to char-array for given argument
     char *curr_arg = argv[i]; 
+
+    // alternative schreibweise:
+    // char *curr_arg = *(argv + i);
+    
+    printf("%s\n", curr_arg);
+  }
+}
+```
+
+### Jeden char der Argumente auf eine eigene Zeile drucken
+Bei diesem Program wurde benutzt, dass in C, char-arrays mit einem '\0'-byte terminiert sind
+```c
+#include <stdio.h>
+
+int main(int argc, char *argv[]) {
+  // iterate over arguments passed to program
+  // start at i = 1, because i = 0 is the name of the program
+  for (int i = 1; i < argc; i++) {
+    // get reference to char-array for given argument
+    char *curr_arg = argv[i];
+
+    // iterate over the current argument, until '\0' is reached (end of string)
     int l = 0;
     while (curr_arg[l] != '\0') {
       printf("%c\n", curr_arg[l]);
@@ -41,3 +103,24 @@ int main(int argc, char *argv[]) {
   }
 }
 ```
+
+### Speicher für structs anlegen
+```c
+#include <stdio.h>
+
+struct listelement {
+  int value;
+  struct listelement *next;
+};
+
+int main(int argc, char *argv[]) {
+  struct listelement *element1 = malloc(sizeof(struct listelement));
+  if (element1 == NULL) {
+    // fehlerbehandlung ...
+  }
+
+  // ... rest vom program
+
+  free(element1)
+}
+```