Taschenrechner mit Zwischenergebnis programmieren

[Wuaegner]

Hi MrSpock!
Ah gut das werd ich gleich ändern. Gab noch einen Fehler... habe ihn gerade gefunden jetzt geht es ohne Probleme. Versuche jetzt mal Mal- und Bruchrechnen einzubauen.

Grüße Flo

[Wuaegner]

Da ich nun wieder weitermachen kann mit meinem TR werde ich dieses Thema nun schließen.
Gruß Flo

[Wuaegner]

Servus! Hab jetzt mal Multiplikation und Division eingeführt bei meinem TR , auch die Punkt-Vor-Strich-Regel , jedoch weiß ich nicht wie ich es anstelle, dass nachdem er die MalRechnung ausgeführt hat den restlichen Stack auch noch abarbeitet.

Delphi-Quellcode:

procedure TForm1.EAusgabeKeyPress(Sender: TObject; var Key: Char);
var
  OpPosition: integer;
  OpAltPosition: integer;
  Zahl,ZahlAlt: extended;
  OpAlt : String;

begin
   inc(anz);
   if (Op <> '') and (anz = 1) then
      EAusgabe.Text := '';

  if Key in [',','0','1','2','3','4','5','6','7','8','9'] then exit;

   if OpPos(Key,OpPosition)= true then        {Wenn key ein Operator ist}
     begin
     Label1.Caption:= Key;
     Zahl:= StrToFloat(EAusgabe.Text);

       if OpStack.IsEmpty= false then
             begin
               Opstack.ShowTopObject(TObject(OpAltPosition));

               if OpAltPosition <= OpPosition then
                    begin

                    ZahlAlt:= StrToFloat(NumStack.Pop);
                    OpAlt:= OpStack.ShowTopObject(TObject(OpAltPosition));

                       case OpAlt[1] of
                        '=','+':
                           begin
                           Zahl:= ZahlAlt + Zahl;
                           EAusgabe.Text:= FloatToStr(Zahl);
                           NumStack.Push(FloatToStr(Zahl));
                           OpStack.PushObject(key,TObject(2)); {+ hat Stärke 2}
                           Anz:= 0;
                           end;
                        '-':
                           begin
                           Zahl:= ZahlAlt - Zahl;
                           EAusgabe.Text:= FloatToStr(Zahl);
                           NumStack.Push(FloatToStr(Zahl));
                           OpStack.PushObject(key,TObject(2));  {- hat Stärke 2}
                           Anz:= 0;
                           end;
                        '*':
                           begin
                           Zahl:= ZahlAlt * Zahl;
                           EAusgabe.Text:= FloatToStr(Zahl);
                           NumStack.Push(FloatToStr(Zahl));
                           OpStack.PushObject(key,TObject(1));   {* hat Stärke 1}
                           Anz:= 0;
                           end;
                        '/':
                           begin
                           Zahl:= ZahlAlt / Zahl;
                           EAusgabe.Text:= FloatToStr(Zahl);
                           NumStack.Push(FloatToStr(Zahl));
                           OpStack.PushObject(key,TObject(1));   {/ hat Stärke 1}
                           Anz:= 0;
                           end;
                      end;

                 end

                   else If OpAltPosition > OpPosition then
                              begin
                              NumStack.Push(FloatToStr(Zahl));
                              OpStack.PushObject(key,TObject(OpPosition));
                              Anz:= 0;
                              exit;
                              end;


               end
                else {if IsEmpty = true}
                  begin
                   Op := Key;
                   Anz:= 0;
                   OpStack.PushObject(key,TObject(OpPosition));
                   NumStack.Push(FloatToStr(Zahl));
                   exit;
                  end;
   end;
   Key:= #0;
end;

Wäre sehr dankbar wenn mir jemand weiterhelfen kann!
Grüße Flo

[MrSpock]

Hallo Flo,

der Taschenrechner darf ja den Rest des Stack gar nicht abarbeiten! Nur bei einer schließenden Klammer muss er den Stack abräumen, bis zur dazugehörigen öffnenden Klammer (die existieren muss!) oder bei einem Gleichheitszeichen, dann muss er den Stack komplett räumen, darf aber nicht mehr auf eine öffnende Klammer stoßen, sonst müsste es einen Fehler geben.

[Wuaegner]

Hallo MrSpock,
Aber ich möchte ja, dass immer das Zwischenergebnis angezeigt wird. Wenn man nun eingibt:
2 + 3 * 4 + 4 dann soll er ja erst 3*4 rechnen und danach noch die 2 addieren und dann erst weiterrechnen. MIt "abarbeiten" meinte ich dass er in dem Fall dann die 2 noch addiert nach der Multiplikation. WIe stelle ich das am besten an? Bis jetzt rechnet er ja 3*4 und danach mit diesem Ergebnis, 12 weiter. Die 2 addiert er noch nicht.
Gruß Flo

[MrSpock]

Hallo Flo,

du musst tatsächlich, wenn du einen Operator findest, der schwächer bindet, als der oberste auf dem Stack, diesen und alle weiteren (in einer Schleife) vom Stack abarbeiten, bis du auf einen Operator triffst, der wieder schwächer bindet.

Beispiel:

3+4*5^2* ergibt auf dem
NumStack:3 4 5 6
OpStack: + * ^
AktOp: *

* bindet schwächer als ^, also alte Operation ausführen und Zwischergebnis zurück auf den Stack.

NumStack 3 4 25
OpStack: + *

Der obere Operator bindet nicht schwächer als der aktuelle und kann auch noch abgearbeitet werden:

Num Stack 3 100
OpStack: +

Der obere Operator (+) bindet jetzt aber schwächer als der aktuelle * und darf noch nicht abgearbeitet werden.

[Wuaegner]

Hallo MrSpock,
Genau nur wie mache ich diese Schleife? sie muss ja die fast die ganze keypressed- prozedur enthalten. Wie ich dieses Schleife geschickte erstelle ohne viel doppelten code zu haben.
Grüße FLo

[MrSpock]

Hallo Flo,

zeig doch einmal deinen Versuch, die Abfrage in einer Schleife darzustellen. Wie es prinzipiell läuft hab ich ja schon beschrieben. Die Stufe der Bindung des Operators holst du dir im Code bereits mit OpAltPosition. Anstatt nur den obersten Eintrag zu betrachten nimmst du eine while Schleife, die immer dann ausgeführt wird, wenn OpAltPosition <= OpPosition ist. Dann führst du den Code aus, den du schon programiiert hast. Am Ende der Schleife prüft du einfach mit ShowTopObject, ob der nun oben liegende Operator immer noch schwächer bindet (und hast damit den neuen Wert für OpAltPosition für die nächste Schleifenbedingung) und holst in diesem Fall mit PopObjekt wieder das oberste Element vom Stack.

Versuche das einmal und poste das Ergebnis, dann können wir dir weiterhelfen.

[Wuaegner]

Um diesen Beitrag abzuschließen, der fertige und funktionierende Taschenrechner steht in der OpenSource Sparte.

[Kudle]

Ich würde mir gerne mal den fertigen Taschenrechner ansehen.

Da ich neu hier bin, würde ich gerne wissen, was mit "Open Source Sparte" gemeint ist?

Gruß