Razorhawk
Webdesigner und MSP
Ich habe gerade mal den Stack erweitert, dass man ihn auch in mehrfacher Ausführung in einem Programm neu instanzieren kann.
...
Mir kommt so der Gedanke dabei, kann es sein, dass ich hier dann praktisch objektorientiert arbeite ohne ein objektorientierte Sprache zu haben?
header datei stack.h
stack.c
...
Mir kommt so der Gedanke dabei, kann es sein, dass ich hier dann praktisch objektorientiert arbeite ohne ein objektorientierte Sprache zu haben?
header datei stack.h
Code:
#ifndef STACK_H
#define STACK_H
/* Hier sollte noch was kommen... - ja nämlich ein Typedef um sich struct sparen zu können... dummes Geschreibsel! ;-) */
typedef struct stack stack;
/* Liefert einen Pointer auf einen neuen Stack. */
extern stack* newStack();
/* Legt den Wert <code>i</code> auf den Stack <code>s</code>. */
extern void push(stack* s, int i);
/* Gibt den obersten Wert des Stacks <code>s</code> zurueck,
* ohne ihn vom Stack zu loeschen. */
extern int top(stack* s);
/* Gibt den obersten Wert des Stacks <code>s</code> zurueck
* und loescht ihn vom Stack. */
extern int pop(stack* s);
/* Liefert als Ergebnis einen Wert der besagt, ob der Stack leer ist.
* 0 => Stack ist nicht leer; 1 => Stack enthaelt keine Werte */
extern int isEmpty(stack* s);
/* Gibt den Stack top->down aus. */
extern void printStack(stack* s);
#endifstack.c
Code:
#include <stdio.h>
#include <stdlib.h>
#include "stack.h"
// struktur wird definiert für eine Liste mit next-pointer und inhaltsvariable
struct stacklist{
int string;
struct stacklist *next;
};
// vorbereiten um ein Stack als Objekt erzeugen zu können -> ermöglicht mehrere Stacks in einem Programm zu verwalten
struct stack{
struct stacklist *top;
};
// Stack wird erstellt
stack* newStack(){
// Speicher allocieren
stack *temp = (stack *)malloc(sizeof(stack));
// oberstes Element NULL (leer setzen)
temp->top = NULL;
return temp;
}
// Element i auf den Stack legen
void push(stack* s, int i){
// speicher für neues Stack element allocieren
struct stacklist *temp = (struct stacklist *)malloc(sizeof(struct stacklist));
// i dem Stack zuweisen
temp->string = i;
// Pointer der neuen Elements auf die alte Liste zeigen lassen
temp->next = s->top;
// Temp-Stack dem Stack-Objekt zuweisen
s->top = temp;
}
int top(stack *s){
// Rückgabe des obersten Elementes ohne entfernen dieses Element vom Stack
return s->top->string;
}
int pop(stack *s){
struct stacklist *temp;
// Rückgabewert Standard auf null 0 = keine Rückgabe möglich
// VORSICHT fehleranfällig falls Nullen im Stack enthalten sind, ist aber nicht naders möglich bei Int Werten.
int popdata=0;
// Falls der Stack nicht leer ist
if (s->top!= NULL){
// Rückgabewert wird oberstes Stackelement zugewiesen
popdata = s->top->string;
// anhängen der Liste ohne oberstes Element an temp
temp = s->top;
kürzere Liste dem Stackobjekt zuweisen
s->top = s->top->next;
// Speicherfreigabe des obersten Stackelements da sonst Adresse gesperrt für das gesammte Programm!
free(temp);
}
return popdata;
}
int isEmpty(stack *s){
// wenn Stack leer dann 1 (= ja ist leer) sonst 0 (= nein ist nicht leer)
if(s->top == NULL){
return 1;
}else{
return 0;
}
}
void stackPrint(stack *s){
// Stack wird mit pop() solange ausgegeben bis er leer ist
// andere Möglichkeit wäre den Stack auszugeben ohne ihn zu leeren
// ist aber in der Aufgabe nicht erwähnt auf welche weise!
while(!isEmpty(s)){
printf("%i\n", pop(s));
}
}
