hallerni98888/info2Praktikum-DobleSpiel
1
0
Fork 0
forked from freudenreichan/info2Praktikum-DobleSpiel
Code Pull Requests 1 Activity

destroy everythingMerge branch 'nick_branch'

Browse Source
This commit is contained in:
Simon May 2025-11-25 14:03:44 +01:00
commit f59489779b
6 changed files with 270 additions and 105 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
.gitignore vendored Normal file
View File

@ -0,0 +1,4 @@
doble_initial.exe
highscores.txt
runStackTest.exe
stack.o

96
makefile
View File

@ -1,49 +1,49 @@
CC = gcc CC = gcc
FLAGS = -g -Wall -lm FLAGS = -g -Wall -lm
ifeq ($(OS),Windows_NT) ifeq ($(OS),Windows_NT)
include makefile_windows.variables include makefile_windows.variables
else else
UNAME = $(shell uname) UNAME = $(shell uname)
ifeq ($(UNAME),Linux) ifeq ($(UNAME),Linux)
include makefile_linux.variables include makefile_linux.variables
else else
include makefile_mac.variables include makefile_mac.variables
endif endif
endif endif
raylibfolder = ./raylib raylibfolder = ./raylib
unityfolder = ./unity unityfolder = ./unity
# -------------------------- # --------------------------
# Initiales Programm bauen (zum ausprobieren) # Initiales Programm bauen (zum ausprobieren)
# -------------------------- # --------------------------
doble_initial: doble_initial:
$(CC) -o doble_initial $(BINARIES)/libdoble_complete.a $(CC) -o doble_initial $(BINARIES)/libdoble_complete.a
# -------------------------- # --------------------------
# Selbst implementiertes Programm bauen # Selbst implementiertes Programm bauen
# -------------------------- # --------------------------
program_obj_files = stack.o bintree.o numbers.o timer.o highscore.o program_obj_files = stack.o bintree.o numbers.o timer.o highscore.o
doble : main.o $(program_obj_files) doble : main.o $(program_obj_files)
$(CC) $(FLAGS) $^ -o doble $(CC) $(FLAGS) $^ -o doble
$(program_obj_filesobj_files): %.o: %.c $(program_obj_filesobj_files): %.o: %.c
$(CC) -c $(FLAGS) $^ -o $@ $(CC) -c $(FLAGS) $^ -o $@
# -------------------------- # --------------------------
# Unit Tests # Unit Tests
# -------------------------- # --------------------------
unitTests: unitTests: stack.o test_stack.c $(unityfolder)/unity.c
echo "needs to be implemented" $(CC) $(FLAGS) -I$(unityfolder) -o runStackTest test_stack.c stack.o $(unityfolder)/unity.c
# -------------------------- # --------------------------
# Clean # Clean
# -------------------------- # --------------------------
clean: clean:
ifeq ($(OS),Windows_NT) ifeq ($(OS),Windows_NT)
del /f *.o doble del /f *.o doble
else else
rm -f *.o doble rm -f *.o doble
endif endif

122
stack.c
View File

@ -1,33 +1,91 @@
#include <stdlib.h> #include <stdlib.h>
#include "stack.h" #include "stack.h"
//TODO: grundlegende Stackfunktionen implementieren: // TODO: grundlegende Stackfunktionen implementieren:
/* * `push`: legt ein Element oben auf den Stack, /* * `push`: legt ein Element oben auf den Stack,
* `pop`: entfernt das oberste Element, * `pop`: entfernt das oberste Element,
* `top`: liefert das oberste Element zurück, * `top`: liefert das oberste Element zurück,
* `clearStack`: gibt den gesamten Speicher frei. */ * `clearStack`: gibt den gesamten Speicher frei. */
// Pushes data as pointer onto the stack. // Pushes data as pointer onto the stack.
StackNode *push(StackNode *stack, void *data) StackNode *push(StackNode *stack, void *data)
{ {
StackNode *tempNode, *newNode;
}
newNode = malloc(sizeof(StackNode));
// Deletes the top element of the stack (latest added element) and releases its memory. (Pointer to data has to be newNode->value = 3;
// freed by caller.) newNode->next = NULL;
StackNode *pop(StackNode *stack)
{ if (stack == NULL)
{
} stack = newNode;
return stack;
// Returns the data of the top element. }
void *top(StackNode *stack)
{ tempNode = stack;
while (tempNode->next != NULL)
} {
tempNode = tempNode->next;
// Clears stack and releases all memory. }
void clearStack(StackNode *stack) tempNode->next = newNode;
{
return stack;
}
// Deletes the top element of the stack (latest added element) and releases its memory. (Pointer to data has to be
// freed by caller.)
StackNode *pop(StackNode *stack)
{
StackNode *tempNode;
if (stack == NULL)
{
return stack;
}
tempNode = stack;
while (tempNode->next->next != NULL)
{
tempNode = tempNode->next;
}
free(tempNode->next);
tempNode->next = NULL;
return stack;
}
// Returns the data of the top element.
void *top(StackNode *stack)
{
StackNode *tempNode;
if (stack == NULL)
{
return NULL;
}
tempNode = stack;
while (tempNode->next != NULL)
{
tempNode = tempNode->next;
}
return &tempNode->value;
}
// Clears stack and releases all memory.
void clearStack(StackNode *stack)
{
StackNode *tempNode;
if (stack == NULL)
{
return;
}
tempNode = stack;
while (tempNode != NULL)
{
tempNode = pop(tempNode);
}
} }

54
stack.h
View File

@ -1,25 +1,29 @@
#ifndef STACK_H #ifndef STACK_H
#define STACK_H #define STACK_H
/* A stack is a special type of queue which uses the LIFO (last in, first out) principle. /* A stack is a special type of queue which uses the LIFO (last in, first out) principle.
This means that with each new element all other elements are pushed deeper into the stack. This means that with each new element all other elements are pushed deeper into the stack.
The latest element is taken from the stack. */ The latest element is taken from the stack. */
#include <stdlib.h> #include <stdlib.h>
//TODO: passenden Datentyp als struct anlegen //TODO: passenden Datentyp als struct anlegen
typedef struct Node {
// Pushes data as pointer onto the stack. int value;
StackNode *push(StackNode *stack, void *data); struct Node* next;
} StackNode;
// Deletes the top element of the stack (latest added element) and releases its memory. (Pointer to data has to be
// freed by caller.) // Pushes data as pointer onto the stack.
StackNode *pop(StackNode *stack); StackNode *push(StackNode *stack, void *data);
// Returns the data of the top element. // Deletes the top element of the stack (latest added element) and releases its memory. (Pointer to data has to be
void *top(StackNode *stack); // freed by caller.)
StackNode *pop(StackNode *stack);
// Clears stack and releases all memory.
void clearStack(StackNode *stack); // Returns the data of the top element.
void *top(StackNode *stack);
#endif
// Clears stack and releases all memory.
void clearStack(StackNode *stack);
#endif

89
test_stack.c Normal file
View File

@ -0,0 +1,89 @@
#include <stdio.h>
#include <stdlib.h>
#include "stack.h"
#include "unity.h"
StackNode* setup(int value, StackNode* next) {
StackNode* node = malloc(sizeof(StackNode)); // allocate memory on heap
if (node == NULL) {
perror("malloc failed");
exit(EXIT_FAILURE); // or handle the error differently
}
node->value = value;
node->next = next;
return node;
}
void test_pop(void)
{
StackNode* node2 = setup(3, NULL);
StackNode* node1 = setup(2, node2);
StackNode* header = setup(1, node1);
StackNode* temp;
temp = pop(header);
int after = 0;
while(temp)
{
after++;
temp = temp->next;
}
TEST_ASSERT_EQUAL_INT(2, after);
TEST_ASSERT_NULL(node1->next);
}
void test_top(void)
{
StackNode* node2 = setup(3, NULL);
StackNode* node1 = setup(2, node2);
StackNode* header = setup(1, node1);
int data = *(int *)top(header);
TEST_ASSERT_EQUAL_INT(node2->value, data);
}
void test_clear()
{
StackNode* node2 = setup(3, NULL);
StackNode* node1 = setup(2, node2);
StackNode* header = setup(1, node1);
StackNode* temp;
clearStack(header);
temp = header;
int after = 0;
while(temp)
{
after++;
temp = temp->next;
}
TEST_ASSERT_NULL(after);
}
void setUp(void)
{
// Falls notwendig, kann hier Vorbereitungsarbeit gemacht werden
}
void tearDown(void)
{
// Hier kann Bereinigungsarbeit nach jedem Test durchgeführt werden
}
int main()
{
UNITY_BEGIN();
printf("============================\nStack tests\n============================\n");
RUN_TEST(test_pop);
RUN_TEST(test_top);
RUN_TEST(test_clear);
return UNITY_END();
}

10
unittest.h Normal file
View File

@ -0,0 +1,10 @@
#ifndef UNITTTESTS_H
#define UNITTTESTS_H
#include <stdio.h>
typedef int (*UnitTestType)(void);
#define RUN_UNIT_TEST(fct) printf("%80s: %d\n", #fct, fct())
#endif