Implementierung stack.c und test_stack.c

stack.c

@@ -1,5 +1,7 @@
+// Funktionen für stack.c erstellt von Harun Faizi am 05.12.25
+
 #include <stdlib.h>
-#include "stack.h"
+#include "stack.h" //Format der Knoten
 
 //TODO: grundlegende Stackfunktionen implementieren:
 /*  * `push`: legt ein Element oben auf den Stack,
@@ -7,27 +9,80 @@
     * `top`: liefert das oberste Element zurück,
     * `clearStack`: gibt den gesamten Speicher frei. */
 
-// Pushes data as pointer onto the stack.
+// Push legt neues Element oben auf Stack
+
+// Paramter:
+// StackNode *stack --> aktuelles Top des Stacks (Zeiger auf obersten Knoten)
+// void *data --> Zeiger auf Element, das gespeichert werden soll (Pointer zum Wert)
+
+// Fkt. gibt einen Zeiger auf neue Top des Stacks zurück
+
 StackNode *push(StackNode *stack, void *data)
 {
+    // Neuer Knoten im Heap im Format StackNode --> newNode ist ein Zeiger darauf
+    StackNode *newNode = malloc(sizeof(StackNode));
 
+    // Speichert den Pointer den Fkt. bekommen hat in Datenfeld/Strukturfeld --> void *data
+    newNode->data = data;
+
+    // Verbindet neuen Knoten mit bisherigen Stack, newNode zeigt jetzt auf das bisherige Top
+    newNode->next = stack;
+
+    return newNode;
 }
 
-// Deletes the top element of the stack (latest added element) and releases its memory. (Pointer to data has to be
-// freed by caller.)
+
+
+// (Pointer to data has to be
+// freed by caller.) --> data selber löschen
+
+// pop löscht das oberste Element
+
+// Parameter:
+// StackNode *stack --> das aktuelle Top
+
+// Fkt. gibt StackNode * zurück, das neue Top des Stacks
+
 StackNode *pop(StackNode *stack)
 {
+    if (stack == NULL) {
+        return NULL;    //wenn Stack leer dann nichts tun
+    }
 
+    StackNode *next = stack->next; // das nächste Element wird neues Top
+    free(stack);                   // altes Top wird aus Speicher entfernt
+    return next;                   // gibt neues Top zurück
 }
 
-// Returns the data of the top element.
+
+// Soll den Daten-Zeiger zurückgeben, der an Top StackNode gespeichert ist
+
+// Parameter:
+// StackNode *stack --> das aktuelle Top
+
+// Fkt. gibt void * zurück --> einen Zeiger auf beliebigen Datentyp
+
 void *top(StackNode *stack)
 {
+    if (stack == NULL){
+        return NULL;    // wenn kein Top Knoten, wird nichts zurückgegeben
+    }
 
+    return stack->data; //Zeiger auf Daten des Top Knoten zuückgeben
 }
 
-// Clears stack and releases all memory.
+// Fkt. löscht alle Knoten des Stacks aus Heap und gibt Speicher frei
+
+// Parameter:
+// StackNode *stack --> das aktuelle Top
+
+// nach Fkt. existiert Stack nicht mehr --> keine Rückgabe
+
 void clearStack(StackNode *stack)
 {
-
+    while (stack != NULL) {         // solange es Knoten gibt mach weiter, am Ende der liste -> NULL
+    StackNode *next = stack->next;  // nächster Knoten wird ausgewählt
+    free(stack);                    // Top wird gelöscht
+    stack = next;                   // nächster Knoten ist stack (Top)
+    }
 }

stack.h

@@ -8,6 +8,10 @@ The latest element is taken from the stack. */
 #include <stdlib.h>
 
 //TODO: passenden Datentyp als struct anlegen
+typedef struct StackNode {
+    void *data;    //Zeiger auf unbekannten Typ oder Struktur --> damit beliebige Daten speichern mgl.
+    struct StackNode *next;    //Zeiger auf nächsten Knoten
+} StackNode;
 
 // Pushes data as pointer onto the stack.
 StackNode *push(StackNode *stack, void *data);

test_stack.c

@@ -0,0 +1,41 @@
+//
+// Created by faizi on 05.12.2025.
+//
+#include <stdio.h>
+#include <stdlib.h>
+#include "stack.h"
+
+int main(void)
+{
+    StackNode *stack = NULL;
+
+    printf("Starte Stack Test\n");
+
+    // push test
+    int *a = malloc(sizeof(int));
+    int *b = malloc(sizeof(int));
+    *a = 10;
+    *b = 20;
+
+    stack = push(stack, a);
+    stack = push(stack, b);
+
+    printf("Top sollte 20 sein, es kommt %d raus\n", *(int*)top(stack));
+
+
+    // pop test
+    stack = pop(stack);
+    printf("Top sollte jetzt 10 sein, es kommt %d raus\n", *(int*)top(stack));
+
+
+    // clearStack test
+    printf("fuehre ClearStack aus...\n");
+
+    clearStack(stack);
+
+    free(a);
+    free(b);
+
+    return 0;
+
+}