Problem mit Zeigern

[grenzgaenger]

Zitat von inherited:

Warum benutzt du nicht die tolle Fähigkeit von Delphi, ObjektOrientiert zu sein?
Erstell dir eine TStack-Klasse die eine (unterklasse) TStackElement oä hat.
Dann gibst du der Stack-Klasse die Funktionen Create, Pop: Integer, Push(a: integer), isEmpty: Boolean, evtl auch Count: integer und den TStackElements Create, read/write-property next: TStackElement sowie irgendein value. Das kann auch ein Pointer sein, das ist dann universeller einsetzbar!

wieso erstellen? ist doch bei delphi schon dabei

[mkinzler]

Da es eine Schulaufgabe ist, geht es dem Lehrer sicherlich darum, das die Schüler lernen, wie man soetwas implementiert und nicht wie man fertigen Code/Klassen/Komponenten benutzt

[praesident]

Zitat von mkinzler:

Da es eine Schulaufgabe ist, geht es dem Lehrer sicherlich darum, das die Schüler lernen, wie man soetwas implementiert und nicht wie man fertigen Code/Klassen/Komponenten benutzt

genau so ist es...klappt bisher auch alles ganz gut

nur hab ich meinen Programmcode nicht ganz vollständig geschrieben, da ich davon ausgegangen war, dass in der postfix-notation maximal 2 zahlen nebeneinander stehen können...aber dem ist ja nicht so...

muss ich jetzt noch erweitern

[Macci]

@praesident:

Zeig doch bitte mal den restlichen Quelltext, wo du die Push und Pop Methoden verwendest. Würde mich persönlich mal interessieren. Freut mich natürlich, dass es klappt

@alzaimar:
Joa genau so isses. Ich hoffe du kannst mir verzeihen, dass ich diesen Code nur schnell schnell hingerotzt hab und an das Freigeben des Speichers zunächst gar nicht dachte. War halt schon spät.

Viele Grüsse,
Macci

[praesident]

Zitat von Macci:

@praesident:

Zeig doch bitte mal den restlichen Quelltext, wo du die Push und Pop Methoden verwendest. Würde mich persönlich mal interessieren. Freut mich natürlich, dass es klappt

@alzaimar:
Joa genau so isses. Ich hoffe du kannst mir verzeihen, dass ich diesen Code nur schnell schnell hingerotzt hab und an das Freigeben des Speichers zunächst gar nicht dachte. War halt schon spät.

Viele Grüsse,
Macci

wenn ich dashinbekommen hab, dass mehrere zahlen nebeneinander stehen können, poste ich mal das prog...
...aber ich denke, das wird alles sehr unsauber für euch sein.

könntest du das mit dem speicher freigeben viellt. mal kurz näher erläutern?
noch etwas, was uns nicht gesagt wurde...

[Macci]

Zitat von praesident:

könntest du das mit dem speicher freigeben viellt. mal kurz näher erläutern?
noch etwas, was uns nicht gesagt wurde...

Also Freigeben ist das Gegenteil von Reserverien (was du z.B. mit "new(zhilf)" machst). Wenn du das Element aus dem Keller holst, ist es nicht nötig, selbiges Element noch weiter im Speicher zu behalten. Deswegen gibt man diesen Speicher dann mit Dispose frei. Würde man auf dieses Freigeben verzichten, würde das Programm zwar trotzdem ganz normal funktionieren aber unter Umständen Unmengen an Speicher verbrauchen. Wenn du z.B. in deinen Keller 1 Million Elemente einlagerst, ist dein Keller ja ca. 5 MB groß (wenn ich die Defintion von TZeiger jetzt richtig im Kopf habe). Holst du anschließend diese Elemente aller wieder raus, wären aber immer noch 5 MB Müll im Hauptspeicher, was natürlich sehr hässlich ist. In Java gibt es dafür z.B. einen Garbage Collector, der diesen Müll automatisch aufsammelt, in Delphi muss man das von Hand machen (was ich übrigens besser finde, weil kein unnötiger Thread aktiv sein muss) - hier mit Dispose. Objekte dagegen müssen mit .Free freigegeben werden.

[praesident]

also ich komm leider i-wie nicht weiter...

wenn ich davon ausgehe, dass bei der postfix-notation natürlich auch mehrere zahlen nebeneinander stehen können...

...da hab ich mir gedacht, lese ich solange die zeichen aus dem stack heraus und schreibe sie in einen zweiten, bis ein operationszeichen kommt- das wird aber nicht in den 2. stack geschrieben..

danach hole ich die letzten beiden zeichen wieder aus dem 2. stack eraus, wandle sie in zahlen um und führe die entsprechende rechenoperation durch

das ergebnis schreibe ich wieder in den 2. stack

dann das ganze von vorne: werte werden von den 1. in den 2. stack geschrieben bis ein operationszeichen kommt....usw.

das problem ist, dass wenn ich ein ergebnis wieder in den 2. stack zurückgebe, dieses schnell 2-stellig wird,
dadurch entsteht widerum ein konflikt mit der char-deklaration des stacks

nun hab ich überlegt, die zeichen einfach in zahlen umzuwandeln und in den 2. stack nur zahlen vom typ double reinzuschreiben..

allerdings müsste ich ja dann auch neue pop und push prozeduren einfügen, die mit double und nicht mit char arbeiten...

habt ihr einen vorschlag, wie ich das umgehen kann?

danke für eure hilfe

[Macci]

Wieso verwendest du dann überhaupt "char" ? Ich würde an deiner Stelle eine eigene Klasse, z.B. TExpression mit der abstrakten Funktion eval() als Nachfahre von TObject anlegen. Und die Nachfahren dieser Klasse sind dann TZahl, TAdd, TSub, TMul und TDiv (ggf. noch weitere Rechenoperationen).

Dann verwendest du statt char einfach TExpression und du kannst wunderbar damit arbeiten.

PS: Benutze lieber extended statt double. Extended verwendet nämlich das native 80Bit Format deines Prozessors, während double umständlich hochgerechnet werden muss.

[alzaimar]

Zitat von Macci:

@alzaimar:
Joa genau so isses. Ich hoffe du kannst mir verzeihen, dass ich diesen Code nur schnell schnell hingerotzt hab und an das Freigeben des Speichers zunächst gar nicht dachte. War halt schon spät.

Ich verzeihe Dir, ausnahmsweise .

Ansonsten ist das schon völlig korrekt, das mit der Idee der TExpression-Klasse. Aber hat der praesident das wirklich schon gelernt? Vielleicht reichen es ja, die Zahlen auf dem Stack zu packen. Klar ist das nicht OOP, aber für den Anfang schon ganz brauchbar.

Dann kann man ein kleines Programm schreiben, das den Stack in einer TListbox darstellt. Darunter ein Eingabefeld und ein Knopf, die Eigenschaft 'Default' ist True, damit der Knopf auf ENTER reagiert. Das ist sozusagen das Eingabefeld des UPN-Taschenrechners. Du tippst etwas ein und drückst ENTER.
Wenn der String in eine Zahl umgewandelt werden kann, dann kommt er auf den Stack.
Handelt es sich um einen Operator ('+', '-', '*', '/') dann werden die obersten beiden Zahlen vom Stack geholt und eben gerechnet. Das Ergebnis kommt wieder auf den Stack.

Das müsste doch hinzubekommen sein, oder?

[Macci]

Hab das jetzt mal für dich gemacht.

Hier der interface-Teil:

Delphi-Quellcode:

type
  TExpression = class
  public
    function eval:Extended; virtual; abstract;
  end;

  TZahl = class(TExpression)
  private
    Fzahl: Extended;
    procedure Setzahl(const Value: Extended);
  public
    constructor Create(zahl:Extended);
    function eval:Extended; override;
    property zahl:Extended read Fzahl write Setzahl;
  end;

  TAdd = class(TExpression)
  private
    FExpr1: TExpression;
    FExpr2: TExpression;
    procedure SetExpr1(const Value: TExpression);
    procedure SetExpr2(const Value: TExpression);
  public
    constructor Create(Expr1,Expr2:TExpression);
    property Expr1:TExpression read FExpr1 write SetExpr1;
    property Expr2:TExpression read FExpr2 write SetExpr2;
    function eval:Extended; override;
  end;

und hier die Implementation:

Delphi-Quellcode:

{ TZahl }

procedure TZahl.Setzahl(const Value: Extended);
begin
  Fzahl := Value;
end;

constructor TZahl.Create(zahl: Extended);
begin
  Fzahl := zahl
end;

function TZahl.eval: Extended;
begin
  result := FZahl
end;

{ TAdd }

constructor TAdd.Create(Expr1, Expr2: TExpression);
begin
 FExpr1 := Expr1;
 FExpr2 := Expr2
end;

function TAdd.eval: Extended;
begin
  result := FExpr1.eval + FExpr2.eval
end;

procedure TAdd.SetExpr1(const Value: TExpression);
begin
  FExpr1 := Value;
end;

procedure TAdd.SetExpr2(const Value: TExpression);
begin
  FExpr2 := Value;
end;

Was natürlich noch fehlt, aber ganz analog funktioniert, ist TSub, TDiv und TMul.

Um zu überprüfen, ob eine TExpression x eine TZahl ist, kannst du folgenden Code benutzen:
if x is TZahl then {.. ist eine Zahl ..}
Verwenden kannst du die Klasse ganz einfach so:

Delphi-Quellcode:

procedure TForm1.Button1Click(Sender: TObject);
var
  num1, num2: TZahl;
  add: TAdd;
begin
  num1:=TZahl.Create(10);
  num2:=TZahl.Create(20);
  add:=TAdd.Create(num1,num2);
  ShowMessage(FloatToStr(add.eval)); //gibt 30 aus
  add.Free;
  num1.Free;
  num2.Free
end;

Wenn du deinen Stack erstellst, weisst du natürlich noch nicht, wie die einzelnen Operationen zusammengehören, deshalb kannst du bei jeder Nicht-Zahl einfach im Create 2 nil's übergeben.
Auf deinem Stack liegen dann lauter TExpressions, die du beim Auslesen des Stacks nur noch richtig "zusammenstopfen" musst, d.h. also, die entsprechenden Properties setzen musst.
Zu guter letzt genügt EIN einziger Aufruf von eval und du hast das Ergebnis ^^