STACK in C

Hallo,

ich will 2 Stacks in C-Sprache initializieren, aber leider weiss ich nicht wie.
Kann mir jemand helfen ? Hier ist die Kode von meinen Dateien:

STACK.h

void STACKinit(void);
  int STACKisempty(void);
  void STACKpush(int item);
  int STACKpop(void);
  int STACKtopAndPop(void);
  int STACKtop(void);

stack.c

#include "STACK.h"
#define MAX_SIZE 1000
static int s[MAX_SIZE];
static int N;
void STACKinit(void) {
N = 0;
}
int STACKisempty(void) {
return N == 0;
}
void STACKpush(int item) {
s[N++] = item;
}
int STACKpop(void) {
return s[--N];
}

int STACKtopAndPop(void) {
return s[--N];
}

int STACKtop(void){
return s[N-1];
}

Vielen Dank
Mincho

Stelfer

also wenn ich das nicht falsch verstanden habe dann mach doch einfach 2 zeiger und übergib einen als parameter

bzw. speicher den stack auf dem heap

Kannst du mir es als Kode schreiben ?

Stelfer

ah sry, war grad in meinem code vertieft, sehe dass du nur int - variablen hast. also vergiss das was ich gesagt habe

hast du schon eine funktion geschrieben, oder hängst du noch an den prototypen ?

Also ich muss eine Funktion schreiben

und hab die Funktion in Internet aber in Java oder in C++ gefunden
und da brauche ich 2 Stacks und geht nicht.
Und bei der Funktionen, die ich mit einem Stack probiert habe, geht irgendwie nicht

Stelfer

wenn du 2 stacks mit int[] brauchst würd ich die erstmal deklarieren und in eine 2 datei deine funktionen auflisten,

um inviduell in einen array einzutippen musst du halt einen parameter übergeben welchen array du halt meinst

void STACKpush(int item, int A[]){
}

z.b

irgednwie verstehe ich nicht was du eigentlich meinst

kannst du bishen klarer sein, vllt am besten mit definition von 2 Stacks und auch Aufruf von STACKpop() z.b.

Stelfer

static int zweiterStack[MAX_SIZE];

int STACKpop(int A[]) { //der parameter dient dazu um einen der 2 stacks auszusuchen
return A[--N];
}

btw. verstehst du was von paramtern usw. ?
wenn nicht dann lies am besten ein kapitel über funktionen, weil sonst kann ich dir gleich den ganzen quelltext schreiben

ah und warum machst du es static ?

Also ich verstehe etwas von Parametern, aber irgendwie verstehe ich nicht wieso definierst du nochmal die pop-Methode.

Also ich hab die Datei stack.c

dort sind alle Methoden fur den Stack definiert und sogar so:

#include "STACK.h"
#define MAX_SIZE 1000
static int s[MAX_SIZE];
static int N;
void STACKinit(void) {
N = 0;
}
int STACKisempty(void) {
return N == 0;
}
void STACKpush(int item) {
s[N++] = item;
}
int STACKpop(void) {
return s[--N];
}

int STACKtopAndPop(void) {
return s[--N];
}

int STACKtop(void){
return s[N-1];
}

und in der Datei

postfix.c

will ich 2 Stacks initialisieren und mit denen arbeiten.

Ich weiss nicht wie das in C-Kode geht.

Z.b in C++ Kode sieht so aus:
Initialisieren:
stack<char> stkPostfix;
stack<char> stkOperator;
Benutzung:
stkOperator.pop();
stkPostfix.pop();

Und genau diese 4 Zeilen will ich in C-Kode haben.

Stelfer

irgendwie komm ich nicht so ganz mit dir auf einen nenner,
habs probiert aber irgendwie versteh ich nicht deine problematik, vielleicht kann dir jemand anders helfen

net 0

Mincho schrieb:

will ich 2 Stacks initialisieren und mit denen arbeiten.

probier's damit:

typedef struct __bytestack
{
   unsigned char *p;
   int top;
   int idx;
} bytestack_t;

bytestack_t *stack_create (unsigned int size)
{
   bytestack_t *bs = malloc (sizeof (bytestack_t));
   if (!bs)
      return 0;
   bs->p = malloc (size);
   if (!bs->p)
   {
      free (bs);
      return 0;
   }
   bs->idx = 0;
   bs->top = size;
   return bs;
}

void stack_destroy (bytestack_t *bs)
{
   free (bs->p);
   free (bs);
}

int stack_push (bytestack_t *bs, unsigned char b)
{
   if (bs->idx == bs->top)
      return -1;
   bs->p[bs->idx] = b;
   bs->idx++;
   return 0;
}

int stack_pop (bytestack_t *bs)
{
   bs->idx--;
   if (bs->idx == -1)
   {
      bs->idx = 0;
      return -1;
   }
   return bs->p[bs->idx];   
}

benutzen kannste es dann z.b. so:

// test
void main (void)
{
   // stack für 3 bytes anlegen
   bytestack_t *stack = stack_create (3);

   // test: zugriff auf leeren stack
   printf ("pop vom leeren stack: %d\n", stack_pop(stack));   // geht schief, stack leer
   puts("");

   // ein paar daten drauf tun
   printf ("1 drauf: %d\n", stack_push (stack, 1));
   printf ("2 drauf: %d\n", stack_push (stack, 2));
   printf ("3 drauf: %d\n", stack_push (stack, 3));
   printf ("4 drauf: %d\n", stack_push (stack, 4));  // geht schief, stack zu klein
   puts("");

   // ausgabe
   printf ("3 runter: %d\n", stack_pop(stack));
   printf ("2 runter: %d\n", stack_pop(stack));
   printf ("1 runter: %d\n", stack_pop(stack));
   printf ("stack leer: %d\n", stack_pop(stack));   // geht schief, stack leer
   printf ("stack leer: %d\n", stack_pop(stack));   // geht schief, stack leer
   puts("");

   // stack löschen
   stack_destroy (stack);
}