Term (Zeichenfolge 1+2*3) in Fließkommazahl

[himitsu]

Bei deiner Schleife würde i zuerst beim + vorbeikommen und dieses auflösen.

Jetzt aber einfach auf die Idee zu kommen die Schleife rückwärts laufen zu lassen wäre auch eine blöde Idee,
(bevor zu also danfängst darüber nachzudenken)
denn 1*2+3 würde dann wiederum falsch ausgewertet.



du mußt einzelne/mehere Schleifen nacheinander machen ... und zwar für alle Stufen einzeln


Vorzeichen (+-) - Punktoperationen (*/) - Strichoperationen (+-) ... genauso, wie man es auch auf'm Zettel selber machen würde

- in der ersten Schleife nur die Vorzeichen (+ und -)
also wenn "{keine Zahl, bzw. Operator} {+|-} {Zahl}"

- dann die nächste Stufe die Punkte (* und : aka /)
also wenn "{zahl} {*|/} {zahl}"

- und nun die Striche (+ und -)
also wenn "{zahl} {+|-} {zahl}"

siehe Beitrag #25

der Funktionsinterpreter vom Delphi-Treff kann das alles in nur einer Schleife machen, da er dort eine andere Verschachtelung der Zahlen und Operatoren genutzt wird.
* + 1 2 3
da kann man immer alles gleich ausrechnen, welches "{operator} {zahl} {zahl}" entspricht und muß auf keine Reihenfolge achten, da die Reihenfolge durch die Verschachtelung vorgegeben wird


also deinen Code erstmal in 2 Schleifen zerlegen

Delphi-Quellcode:

begin
               i:=0;
               while i < SL.Count do 
                  begin
                      if SL[i]='*' then
                         begin
                               SL[SL.Count-1]:=(FloatToStr(StrToFloat(SL[i-1])*StrToFloat(SL[i+1])));
                               {Zahl vor und nach dem * werden multipliziert und in die Zeile der ersten Zahl geschrieben???}
                               SL.Delete(SL.Count);
                               {Jetzt soll die Zeile des Operators gelöscht werden}
                               SL.Delete(SL.Count);{und die der zweiten Zahl}
                               {etwas wurde gefunden - fange von vorn an}
                               i := 0;
                         end
                      else
                      if SL[i]='/' then
                         begin
                               SL[SL.Count-1]:=(FloatToStr(StrToFloat(SL[i-1])/StrToFloat(SL[i+1])));
                               SL.Delete(SL.Count);
                               SL.Delete(SL.Count);
                               i := 0;
                         end
                      else 
                         i := i + 1;
                  end;
               i:=0;
               while i < SL.Count do 
                  begin
                      if SL[i]='+' then
                         begin
                               SL[SL.Count-1]:=(FloatToStr(StrToFloat(SL[i-1])+StrToFloat(SL[i+1])));
                               SL.Delete(SL.Count);
                               SL.Delete(SL.Count);
                               i := 0;
                         end
                      else
                      if SL[i]='-' then
                         begin
                               SL[SL.Count-1]:=(FloatToStr(StrToFloat(SL[i-1])-StrToFloat(SL[i+1])));
                               SL.Delete(SL.Count);
                               SL.Delete(SL.Count);
                               i := 0;
                         end
                      else 
                         i := i + 1;
                  end;

wenn am Ende mehr als ein Eintrag in SL vorliegt, dann stimmte etwas mit dem Term nicht, bzw. du hast etwas noch nicht umgewandelt (z.B. weil der Operator/Befehl noch nicht implementiert ist)
hier z.B. "1 + 2 2 * 3" würde dein Code jetzt "3 6" ausgeben, da die letzen 2 Einträge nicht behandelt werden