malloc Überprüfung

I2_Dobble/Stack.md

@@ -1,42 +1,46 @@
-# stack.h  
+# stack.h
-*Aufgabe: passender Dateityp als struct anlegen*  
+*Aufgabe: passender Datentyp für ein Listenelement als struct anlegen*
-  
+
 ``` c
 typedef struct Node
 {
-  void *data;
+void *data;
-  struct Node* next;
+struct Node* next;
 } StackNode;
 ```
-  
+
-* typedef nicht zwingend notwendig, aber erleich­tert später den Aufruf: StackNode vs struct stackNode  
+* **typedef** nicht zwingend notwendig, aber erleich­tert später den Aufruf: `StackNode` vs `struct stackNode`
-* Zeiger data für Speicher  
+* **Zeiger data** zeigt auf in Liste gespeicherten Wert
-* struct-Node-Zeiger, der auf in der Liste folgendes Node zeigen wird (oder NULL wenn nicht vorhanden)  
+* **Zeiger auf Node struct**, der auf das folgende Node zeiget (oder NULL ist, wenn kein folgendes vorhanden)
-* für jedes struct dieses Typs, dass wir später in den Stack.c Funktionen erstellen muss Speicher manuell zugewiesen werden!  
+* für jedes struct dieses Typs, dass wir später in den Stack.c Funktionen erstellen muss Speicher manuell zugewiesen werden!
 
 
-# stack.c  
+# stack.c
 
-### push:  
+### push:
-*neues Element oben auf die Liste legen*  
+*neues Element oben auf die Liste legen*
-* Sicherheits-Überprüfung: falls übergebener Pointer für Daten kein Ziel (= NULL) hat ⇒ alle Schritte werden übersprungen, Stack- Pointer wird unverändert zurück gegeben  
+* Sicherheits-Überprüfung: falls übergebener Pointer für Daten kein Ziel hat (data = NULL) => alle unten beschriebenen Schritte werden übersprungen, Stack- Pointer wird unverändert zurück gegeben
-* Listerelement erstellen: Standard Ablauf für Structs: erst ein Pointer, dann mit malloc an diesem Ort Speicher in der richtigen Größe reservieren (hier Größe eines Listenelements), dann kann Speicher genutzt werden  
+* Listenelement erstellen: (Standard Ablauf für Structs)
-* data wird gespeichert  
+  * Pointer initialisieren
-* next passend setzen, entweder bisher oberstes Element oder keines, wenn Liste leer war  
+  * mit malloc an diesem Ort im Speicher in der richtigen Größe reservieren (hier Größe eines Listenelements)
-* stach-Pointer auf neues, oberstes Listetenelement zeigen lassen  
+  * Speicher kann genutzt werden
-  
+* data wird gespeichert
-### pop:  
+* next passend setzen, entweder zuvor oberstes Element oder keines, wenn Liste leer war
-*oberstes Element von Liste löschen*  
+* stack-Pointer auf neues, oberstes Listetenelement zeigen lassen
-* Sicherheits-Überprüfung: wenn Stack schon leer wird nichts entfernt (Stack = NULL bedeutet kein erstes Element existiert)  
+
-* zum Löschen. wird speicher am Ort des stach-Zeigers freigegeben - damit ist das oberste Element weg  
+### pop:
-* zuletzt wird der Stack-Zeiger neu gesetzt f neues oberstes Listerelement  
+*oberstes Element von Liste löschen*
-  
+* Sicherheits-Überprüfung: wenn Stack schon leer ist wird nichts entfernt (Stack = NULL bedeutet kein erstes Element existiert) - sonst würde nicht reservierter Speicher freigegeben
-### top:  
+* müssen alle Zeiger auf das Element ändern und den Speicher Freigeben - damit ist alles entfernt:
-*gibt Daten-Zeiger des obersten Elements zurück*  
+* zum Löschen wird Speicher am Ort des stack-Zeigers freigegeben - damit ist das oberste Element weg
-* Sicherheits-Überprüfung: existiert ein oberstes Element überhaupt? sonst würde man beim Versuch data auszulesen auf nicht oder anders zugewiesenen Speicher zugreifen!  
+* zuletzt wird der Stack-Zeiger neu gesetzt, um auch alle Pointer, die noch auf das gelöschte Element zeigen zu aktuallisieren
-* zur normalen Ausgabe wird einfach der Zeigerwert der data-Variable des oberster Stackelements zurückgegeben  
+
-  
+### top:
-### clear stack:  
+*gibt Daten-Zeiger des obersten Elements zurück*
-*die Liste leeren inklusive Speicherfreigabe*  
+* Sicherheits-Überprüfung: existiert ein oberstes Element überhaupt? sonst würde man beim Versuch data auszulesen auf überhaupt nicht bzw anders zugewiesenen Speicher zugreifen!
-* Funktionsprinzip: so lange das oberste Element mit pop-funktion entfernen, bis die Liste leer ist  
+* zur normalen Ausgabe wird einfach der Zeigerwert der data-Variable des oberster Stackelements zurückgegeben
-* da pop erkennt, wenn Liste leer und dann den Stack-Pointer NULL setzt dient das als Schleifenvariable  
+
+### clear stack:
+*die Liste leeren inklusive Speicherfreigabe*
+* Funktionsprinzip: so lange das oberste Element mit pop-funktion entfernen, bis die Liste leer ist
+* da pop erkennt, wenn Liste leer und dann den Stack-Pointer NULL setzt dient das als Schleifenvariable

I2_Dobble/bintreeTest.c

@@ -14,7 +14,7 @@ void test_addToTree_single_element(void)
 {
     TreeNode *root = NULL;
     int value = 10;
-    int dup = -1;
+    int dup;
 
     root = addToTree(root, &value, sizeof(int), compare, &dup);
 
@@ -29,7 +29,7 @@ void test_addToTree_multiple_elements_and_size(void)
 {
     TreeNode *root = NULL;
     int values[] = {5, 3, 7, 1, 4};
-    int dup = -1;
+    int dup;
 
     for (int i = 0; i < 5; i++)
         root = addToTree(root, &values[i], sizeof(int), compare, &dup);
@@ -91,7 +91,7 @@ void test_treeSize_returns_correct_size()
     TreeNode *root = NULL;
     int values[] = {8, 3, 10, 1, 6, 14};
 
-    // ersten Baum aufbauen
+    //Baum aufbauen
     for (int i = 0; i < 6; i++)
         root = addToTree(root, &values[i], sizeof(int), compare, NULL);
 
@@ -107,6 +107,8 @@ void test_treeSize_returns_correct_size()
 int main(void)
 {
     UNITY_BEGIN();
+    
+    printf("\n============================\n Bintree tests\n============================\n");
 
     RUN_TEST(test_addToTree_single_element);
     RUN_TEST(test_addToTree_multiple_elements_and_size);

I2_Dobble/numbers.c

@@ -16,9 +16,7 @@ static void dublicateRandomEntry (unsigned int *numbers, unsigned int len)
    if (numbers && len > 2)
    {
         unsigned int dubIndx = rand() % (len - 1);
-        unsigned int copyIndx;
+        unsigned int copyIndx = rand() % len;
-        
-        copyIndx = rand() % len;
 
         numbers[len - 1] = numbers[dubIndx];
 
@@ -69,7 +67,7 @@ unsigned int *createNumbers(unsigned int len)
     // Duplicate one random entry
     dublicateRandomEntry(numbers, len);
 
-    clearTree(root); //Notwendigkeit muss noch restlichem Code entnommen werden
+    clearTree(root);
     return numbers;
 }
 

I2_Dobble/numbersTest.c

@@ -54,28 +54,6 @@ void test_getDuplicate_returns_correct_value(void)
     TEST_ASSERT_EQUAL_UINT(7, d);
 }
 
-void test_complete_function_of_numbers(void) 
-{
-    unsigned int len = 50;
-    unsigned int *arr = createNumbers(len);
-    TEST_ASSERT_NOT_NULL(arr);
-
-    unsigned int d1 = getDuplicate(arr, len);
-    TEST_ASSERT_NOT_EQUAL(0, d1);
-
-    int count = 0;
-
-    for (unsigned int i = 0; i < len; i++) 
-    {
-        if (arr[i] == d1) 
-            count++;
-    }
-
-    TEST_ASSERT_EQUAL(2, count);
-
-    free(arr);
-}
-
 void setUp(void) { }
 void tearDown(void) { }
 
@@ -83,11 +61,12 @@ int main(void)
 {
     UNITY_BEGIN();
 
+    printf("\n============================\n Numbers tests\n============================\n");
+
     RUN_TEST(test_createNumbers_no_null);
     RUN_TEST(test_createNumbers_has_exactly_one_duplicate);
     RUN_TEST(test_createNumbers_has_correct_value_range);
     RUN_TEST(test_getDuplicate_returns_correct_value);
-    RUN_TEST(test_complete_function_of_numbers);
 
     return UNITY_END();
 }

I2_Dobble/stack.c

@@ -15,6 +15,10 @@ StackNode *push(StackNode *stack, void *data)
     {
         StackNode *newNode;
         newNode = (StackNode *)malloc(sizeof(StackNode));
+        if (!newNode) 
+            printf("Speicherfehler: nicht genug Speicher");
+            return stack;
+
         newNode->data = data;
         
         //         ,-→ bedeutet Liste war leer - das neue Element hat keinen Nachfolger (next = NULL)