Atari Computer

Beispiel: Stack

Die folgenden Beispiele zeigen einen Stack.

Sprache	C	Pascal	Modula
Beispiel	stack.c	stack.pas	stack.mod

stack.c

/* Da der Datentyp des Stacks erst bei einer konkreten Anwendung */
/* feststeht, ist der Stack nur als Beispiel und nicht als Modul */
/* programmiert. Mit mehr Aufwand k�nnte man auch Zeiger auf die */
/* Daten (in Pascal �ber variante Records als long_integer) ab-  */
/* speichern und damit einen universellen Stack implementieren.  */

#include 
#include 

typedef long StackDataType;
typedef struct stack_element {
   StackDataType Daten;
   struct stack_element *Next;
} StackElement, *StackKnoten;
typedef StackKnoten Stack;

void StackCreate(Stack *MyStack)
{
   *MyStack = NULL;
}

int StackIsEmpty(Stack MyStack)
{
   return(MyStack == NULL);
}

void StackPush(Stack *MyStack, StackDataType Daten)
{  StackKnoten NewElement;

   NewElement = malloc(sizeof(StackElement));
   NewElement->Daten = Daten;
   NewElement->Next = *MyStack;
   *MyStack = NewElement;
}

void StackPop(Stack *MyStack)
{  StackKnoten OldElement;

   if (!StackIsEmpty(*MyStack))
   {
      OldElement = *MyStack;
      *MyStack = (*MyStack)->Next;
      free(OldElement);
   }
}

void StackTop(Stack MyStack, StackDataType *Daten)
{
   if (!StackIsEmpty(MyStack))
      *Daten = MyStack->Daten;
}

stack.pas

(* Da der Datentyp des Stacks erst bei einer konkreten Anwendung *)
(* feststeht, ist der Stack nur als Beispiel und nicht als Modul *)
(* programmiert. Mit mehr Aufwand k�nnte man auch Zeiger auf die *)
(* Daten (in Pascal �ber variante Records als long_integer) ab-  *)
(* speichern und damit einen universellen Stack implementieren.  *)

type
   StackDataType = long_integer;
   StackKnoten = ^StackElement;
   StackElement = record
      Daten : StackDataType;
      Next : StackKnoten;
   end;
   Stack = StackKnoten;

procedure StackCreate(var MyStack:Stack);
begin
   MyStack := nil;
end;

function StackIsEmpty(MyStack:Stack) : boolean;
begin
   StackIsEmpty := MyStack=nil;
end;

procedure StackPush(var MyStack:Stack; Daten:StackDataType);
var
   NewElement:StackKnoten;
begin
   new(NewElement);
   NewElement^.Daten := Daten;
   NewElement^.Next := MyStack;
   MyStack := NewElement;
end;

procedure StackPop(var MyStack:Stack);
var
   OldElement : StackKnoten;
begin
   if not StackIsEmpty(MyStack) then
   begin
      OldElement := MyStack;
      MyStack := MyStack^.Next;
      dispose(OldElement);
   end;
end;

procedure StackTop(MyStack:Stack; var Daten:StackDataType);
begin
   if not StackIsEmpty(MyStack) then
      Daten := MyStack^.Daten;
end;

stack.mod

(* Da der Datentyp des Stacks erst bei einer konkreten Anwendung *)
(* feststeht, ist der Stack nur als Beispiel und nicht als Modul *)
(* programmiert. Mit mehr Aufwand k�nnte man auch Zeiger auf die *)
(* Daten (in Pascal �ber variante Records als long_integer) ab-  *)
(* speichern und damit einen universellen Stack implementieren.  *)

FROM Heap IMPORT Allocate, Deallocate;
FROM SYSTEM IMPORT TSIZE;

TYPE
   StackDataType = LONGINT;
   StackKnoten = POINTER TO StackElement;
   StackElement = RECORD
      Daten : StackDataType;
      Next : StackKnoten;
   END;
   Stack = StackKnoten;

PROCEDURE StackCreate(VAR MyStack:Stack);
BEGIN
   MyStack := NIL;
END StackCreate;

PROCEDURE StackIsEmpty(MyStack:Stack) : BOOLEAN;
BEGIN
   RETURN MyStack=NIL;
END StackIsEmpty;

PROCEDURE StackPush(VAR MyStack:Stack; Daten:StackDataType);
VAR
   NewElement:StackKnoten;
BEGIN
   Allocate(NewElement, TSIZE(StackElement));
   NewElement^.Daten := Daten;
   NewElement^.Next := MyStack;
   MyStack := NewElement;
END StackPush;

PROCEDURE StackPop(VAR MyStack:Stack);
VAR
   OldElement:StackKnoten;
BEGIN
   IF NOT StackIsEmpty(MyStack) THEN
      OldElement := MyStack;
      MyStack := MyStack^.Next;
      Deallocate(OldElement, TSIZE(StackElement));
   END;
END StackPop;

PROCEDURE StackTop(MyStack:Stack; VAR Daten:StackDataType);
BEGIN
   IF NOT StackIsEmpty(MyStack) THEN
      Daten := MyStack^.Daten;
   END;
END StackTop;

English version not yet available.