Stack programmieren / postfix

[robbespierre]

hallo,
ich soll einen postfixausdruck ins programm eingeben können und das programm berechnet es per buttonklick, die speicherung soll per selbstprogrammierten stack laufen, aber k.a. warum das nicht geht, zeigt immer fehler an

also die projektunit sieht so aus:

Delphi-Quellcode:

unit postverfahren;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls;

type
  TForm1 = class(TForm)
    Button1: TButton;
    Edit1: TEdit;
    Edit2: TEdit;
    procedure Button1Click(Sender: TObject);
    procedure Edit2Change(Sender: TObject);
    procedure FormActivate(Sender: TObject);

  private
    { Private declarations }
  public
    { Public declarations }
  end;

var
  Form1: TForm1;
  leer:boolean;
  neu:integer;
  operator:shortstring;

implementation

uses post;

{$R *.dfm}

PROCEDURE rechne(operator:shortstring; VAR head,tail,raus:tzeiger;VAR neu:integer);
VAR  zahl1,zahl2:integer;
     zeichen:char;
BEGIN
    get(head,tail,raus);
    zahl1:=raus^.inhalt;
    get(head,tail,raus);
    zahl2:=raus^.inhalt;
    zeichen:=operator[1];
    CASE zeichen OF
     '+':neu:=zahl2+zahl1;
     '-':neu:=zahl2-zahl1;
     '*':neu:=zahl2*zahl1;
     '/':neu:=zahl2 DIV zahl1;
    END;
     put(head,tail,leer,neu);
END;

procedure TForm1.Button1Click(Sender: TObject);
VAR   i:byte;
      hilf,laenge:integer;
      op:boolean;
begin
  laenge:=length(edit1.text);
  FOR i:=1 TO laenge DO BEGIN
     CASE (edit1.text[i]) OF
     '+':BEGIN rechne((edit1.text[i]),head,tail,raus,neu);op:=true;END;
     '-':BEGIN rechne(edit1.text[i],head,tail,raus,neu);op:=true;END;
     '*':BEGIN rechne(edit1.text[i],head,tail,raus,neu);op:=true;END;
     '/':BEGIN rechne(edit1.text[i],head,tail,raus,neu);op:=true;END;
     END;
     IF op=false THEN BEGIN hilf:=strtoint(edit1.text[i]);
                            put(head,tail,leer,hilf);
                            END;
     END;
end;

procedure TForm1.Edit2Change(Sender: TObject);
begin
    edit2.Text:=inttostr(neu);
end;

procedure TForm1.FormActivate(Sender: TObject);
begin
       init(head,tail);
end;


end.

und die stackspeicherung so:

Delphi-Quellcode:

unit post;

interface

type tzeiger = ^tknoten;
     tknoten = RECORD
                 inhalt:integer;
                 znaechster:tzeiger;
               END;
     PROCEDURE init(VAR head,tail:tzeiger);
     PROCEDURE empty(head,tail:tzeiger;VAR leer:boolean);
     PROCEDURE put(VAR head,tail:tzeiger;leer:boolean;neu:integer);
     PROCEDURE get(VAR head,tail:tzeiger;VAR raus:tzeiger);
VAR hilfe1,hilfe2,head,tail,element,raus:tzeiger;
    leer:boolean;
    neu:string;

implementation



PROCEDURE init(VAR head,tail:tzeiger);
BEGIN
    head:=NIL;
    tail:=NIL;
END;

PROCEDURE empty(head,tail:tzeiger;VAR leer:boolean);
BEGIN
   IF head=tail THEN leer:=true
               ELSE leer:=false;
END;

PROCEDURE put(VAR head,tail:tzeiger;leer:boolean;neu:integer);
BEGIN

   empty(head,tail,leer);
   IF leer THEN BEGIN new(element);
                      element^.inhalt:=neu;
                      tail:=element;
                      head:=element;
                      element:=NIL;
                      END
           ELSE BEGIN new(tail^.znaechster);
                      tail^.znaechster^.inhalt:=neu;
                      tail:=tail^.znaechster;
                      tail^.znaechster:=NIL;
                      END;
END;

PROCEDURE get(VAR head,tail:tzeiger;VAR raus:tzeiger);
BEGIN
   hilfe1:=head;
   IF hilfe1<>tail THEN BEGIN WHILE hilfe1<>tail DO BEGIN hilfe2:=hilfe1;hilfe1:=hilfe1^.znaechster;END;end
                   ELSE hilfe2:=hilfe1;
   raus:=tail;
   tail:=hilfe2;
   tail:=NIL;
END;

end.

hoffe jemand kann helfen, und bitte ganze schnell, brauchs zu übermorgen!!!!

thx

[edit=Jelly]Delphi Tags gesetzt, und Sprache auf Win32 angepasst (davon geh ich mal aus)... Nächstes Mal bitte selber machen... Mfg, Jelly[/edit]

[sx2008]

Also dein Stack ist nicht das Gelbe vom Ei.
Ein Stack hat 3 Grundfunktionen:

Delphi-Quellcode:

procedure Push(x: Tdaten);
function Pop:TDaten;
function IsEmpty:boolean;

Deine Stackfunktionen schleppen Head und Tail als Argumente mit sich rum.
Das ist nicht gut. Head und Tail sollten für den Benutzer des Stacks unsichtbar sein.

Es gibt übrigens die Klasse TStack in der VCL. Wenn du die benuten kannst, hast du ein Problem weniger.

[Corpsman]

Dieses Sample ist zwar keine Implementierung eines Stacks ansich, aber es zeigt wie man so was machen könnte.

Wenn du nur die Methoden

AddFront ( als Push )

Getindex(0) ( als Pop)

und
Count = 0 als ( als isempty ) nutzt,

dann kannst du damit einen Stack "Simulieren"

[alzaimar]

Bitte editiere deinen Beitrag, markiere den Delphicode und klicke im Beitragseditor oben auf den Knopf 'Delphi-Code'. Dann wieder speichern und danach ist Dein Code auch lesbar.

[taaktaak]

Bonjour Robespierre, comment ca va?

Wie wäre es mit folgendem Beispiel für einen universellen LiFo-Puffer...

Delphi-Quellcode:

type _Mem_Space       = Array[0..maxInt-1]of Byte;   
     _L_List          = ^_L_List_Node;                  
     _L_List_Node     = record                 
                         Size  : Integer;
                         Info  : ^_Mem_Space;
                         Next  : _L_List end;
     TLiFo            = _L_List;     

// ----------------------------------------------------- LiFo - LastIn/FirstOut

procedure InitLiFo(var L:TLiFo);
begin
  L:=nil;
end;

procedure FreeLiFo(var L:TLiFo);
var p : TLiFo;
begin
  while L<>nil do begin
    p:=L;
    with p^ do begin
      FreeMem(Info,Size);
      L:=Next;
      end;
    end;
end;

function IsEmpty(L:TLiFo):Boolean;
begin
  Result:=L=nil
end;

function LiFoCount(L:TLiFo):Integer;
var p : TLiFo;
begin
  Result:=0;
  while L<>nil do begin
    p:=L;
    L:=p^.Next;
    inc(Result);
    end;
end;

procedure Push(var L:TLiFo;var Value;Len:Integer);
var p : TLiFo;
begin
  new(p);
  with p^ do begin
    Size:=Len;
    Next:=L;
    GetMem(Info,Size);
    Move(Value,Info^,Size);
    end;
  L:=p;
end;

procedure Pop(var L:TLiFo;var Value;Len:Integer);
var p : TLiFo;
begin
  p:=L;
  with p^ do begin
    if Size<>Len then begin ShowMessage('Variablenlänge inkompatibel');
                            exit;
                            end;
    Move(Info^,Value,Size);
    FreeMem(Info,Size);
    L:=Next;
    end;
end;