Erste Versuche zu Parsen um mit String zu rechnen

[MarquiseDeSade]

Hallo DP´ler :lol:

Eine kurze Beschreibung was ich mir Überlegt habe. Ich möchte einen Taschenrechner so programmieren, dass der User durch klicken auf Buttons willkürliche Rechnungen durchführen kann.

Zum Beispiel:
2+22+4-258*635/741 (Die Eingabe erfolgt über Buttons, sowohl die Zahlen als auch Operatoren)

Nun besteht ja das Problem Punkt vor Strich.

Mein Ansatz:

Delphi-Quellcode:

var
  Form1: TForm1;

  speicher                          :string;
  plus,minus,mal,geteilt            :integer;

...
...
...

{Button für die Rechenarten}
{-----------------------------------------------------------}
procedure TForm1.Button_plusClick(Sender: TObject);

begin
  speicher:=speicher+edit1.text+'+';
  edit1.Text:='';
end;
procedure TForm1.Button_minusClick(Sender: TObject);
begin
  speicher:=speicher+edit1.text+'-';
  edit1.Text:='';
end;
procedure TForm1.Button_malClick(Sender: TObject);

begin
  speicher:=speicher+edit1.text+'*';
  edit1.Text:='';
end;
procedure TForm1.Button_geteiltClick(Sender: TObject);
begin
  speicher:=speicher+edit1.text+'/';
  edit1.Text:='';
end;
{-----------------------------------------------------------}

...
...
...
procedure TForm1.Button_gleichClick(Sender: TObject);

begin
speicher:=speicher+edit1.text;

//Übergabe der Position des Zeichens im String
plus:=pos('+',speicher);
minus:=pos('-',speicher);
mal:=pos('*',speicher);
geteilt:=pos('/',speicher);

Nun zu meinen Problemen:
Ich habe leider erst sehr wenige Grundkenntnisse und ich komme hier nicht weiter. Eigentlich habe ich vor, den String bis zu den jeweiligen Operatoren zu zerlegen und ihn als Integer einer Variable zu übergeben. Pos liefert mir aber nur das erste übereinstimmende Zeichen wieder. Wie löse ich also das Problem, wenn in einem String mehrere Plus-Zeichen auftauchen.

[jfheins]

Such mal nach parsen oder Parser da solltest du einiges finden ;)

Du solltest zuerst einen binären Baum erstellen, der den Ausdrück repräsentiert, den kannst du dann ner (rekursieven) Funktion übergeben, die dir dann das Ergebnis ausrechnet ;)

[Jakob Ullmann]

Nimm doch die Kompo TParser (so heisen sicherlich viele) - die findest du bei www.torry.net. :spin2: :wink:

[MarquiseDeSade]

Zitat:

Zitat von jfheins

Such mal nach parsen oder Parser da solltest du einiges finden ;)

Du solltest zuerst einen binären Baum erstellen, der den Ausdrück repräsentiert, den kannst du dann ner (rekursieven) Funktion übergeben, die dir dann das Ergebnis ausrechnet ;)

:?:

Ich finde, dass die Ergebnisse der Suchfunktion mir als Anfänger nicht genug her geben, um mein Problem davon abzuleiten und eine Lösung zu finden... :(

Gibt es vielleicht einen guten Beitrag, der einem die Grundlagen vermittelt? Würde ich mit Pos und Copy dem Problem Herr werden ? Ich probiere schon ein bissl rum, aber zufrieden bin ich noch nicht....

Zitat:

Zitat von Jakob Ullmann

Nimm doch die Kompo TParser (so heisen sicherlich viele) - die findest du bei www.torry.net. :spin2: :wink:

Ich lerne nichts, wenn ich mir fertige Sachen irgendwo herhole und sie dann noch nichtmal verstehe :zwinker:

[sirius]

Warst du schonmal auf dieser Seite?

[MarquiseDeSade]

Jap, war ich schon.... fand ich jetzt nicht so überragend :mrgreen:

Ich merke schon, es wird besser sein, ein wenig rumzuprobieren und dann konkrete Probleme zu posten.

[sirius]

Zitat:

Zitat von MarquiseDeSade

Jap, war ich schon.... fand ich jetzt nicht so überragend :mrgreen:

Echt? Das ist doch super erklärt!

Nimm dir doch einfach mal die paar Zeile Quellcode unter Grundprinzip (damit geht allerdings nur + und *) und schau mal im Debugger was passiert.

Die einzige Hürde, die du nehmen musst sind "rekursive Funktionen", also Funktionen die sichselber aufrufen (im Beispiel: "TermToReal")

[MarquiseDeSade]

Huhu :lol:

Mh, ich stoß hier bei dem Beispiel an meine Grenzen. Ich glaub ich such mir eine andere Möglichkeit, denn das Parsen scheint nicht mein Ding zu sein... zumal mir das alles zu aufwenig erscheint. Es muss doch eine einfachere Möglichkeit geben !! :cry:

[Gremlin]

Die Seite fand ich relativ interessant und passt zu deinem Thema

Hier gehts lang ;-)


a) Auch wenn du es am Anfang vielleicht nicht verstehst, dann lies es nochmal durch
b) goto a)

[Khabarakh]

Wenn du wirklich nur die vier Grundrechenarten und keine Klammern unterstützen willst, existiert in der Tat eine einfache Möglichkeit ohne Lexer oder Baum. Du benötigst eine Funktion

Delphi-Quellcode:

Parse(aTerm: string): Double bzw. Int

In dieser Funktion suchst du nach einem Operator, in dieser Reihenfolge: +,-,*,/. Ist die Suche erfolgreich, rufst du deine Funktion rekursiv mit den Teiltermen links und rechts vom Operator auf und verbindest die Ergebnisse durch den Operator. Für + also zum Bleistift:

Delphi-Quellcode:

Result := Parse(TermLinks) + Parse(TermRechts);
// Exit;

Sobald kein Operator mehr gefunden wurde, muss der restliche Term eine Zahl sein (oder eben nicht -> Exception).

[Christian Seehase]

Moin,

Um so einen String korrekt zu berechnen, muss man als erstes einmal die Punkt- vor Strichrechnung berücksichtigen.
Da bei der rekursiven Berechnung das was man als letztes prüft als dann aber als erstes tatsächlich berechnet wird, muss also zuerst auf die Operatoren mit der niedrigsten Priorität, also +/- geprüft werden.

Delphi-Quellcode:

function Calculate(const AsTerm : string) : extended;

var
  sLinks  : string;
  sRechts : string;

begin
  // Als erstes also mal prüfen, ob wir ein + im Term haben
  if pos('+',AsTerm) > 0 then begin
    // Wenn das der Fall ist müssen also der Teil links des + und der Teil rechts des + addiert werden
    // Hierzu muss man dann einfach alles bis zum + (ohne das + natürlich)
    // wieder an diese Funktion übergeben, damit alle weiteren Zahlen und Operatoren verarbeitet werden
    // Für das Kopieren des Restes muss man übrigens nicht die Länge des verbleibenden Strings benutzen,
    // Da Copy aufhört zu kopieren, wenn das Ende des Strings erreicht ist. Deshalb MaxInt. Mehr geht eh' nicht
    sLinks  := trim(copy(AsTerm,1,pos('+',AsTerm)-1));
    sRechts := trim(copy(AsTerm,pos('+',AsTerm)+1,MaxInt));
    Result  := Calculate(sLinks) + Calculate(sRechts);
  end else begin
    if pos('-',AsTerm) > 0 then begin // Analog zu +, nur eben -
      sLinks  := trim(copy(AsTerm,1,pos('-',AsTerm)-1));
      sRechts := trim(copy(AsTerm,pos('-',AsTerm)+1,MaxInt));
      Result  := Calculate(sLinks) - Calculate(sRechts);
    end else begin
      if pos('*',AsTerm) > 0 then begin // Analog zu +, nur eben *
        sLinks  := trim(copy(AsTerm,1,pos('*',AsTerm)-1));
        sRechts := trim(copy(AsTerm,pos('*',AsTerm)+1,MaxInt));
        Result  := Calculate(sLinks) * Calculate(sRechts);
      end else begin
        if pos('/',AsTerm) > 0 then begin // Analog zu +, nur eben /
          sLinks  := trim(copy(AsTerm,1,pos('/',AsTerm)-1));
          sRechts := trim(copy(AsTerm,pos('/',AsTerm)+1,MaxInt));
          Result  := Calculate(sLinks) / Calculate(sRechts);
        end else begin
          if AsTerm <> '' then begin
            // Wenn kein Operator enthalten war, aber noch ein Reststring übrig ist, muss das eine Zahl sein
            Result := StrToFloat(AsTerm);
          end else begin
            // Handelt es sich um einen Leerstring wird 0 zurückgegeben.
            // Das spart einem die Prüfung auf ein Vorzeichen, wie z.B. bei -1+5
            Result := 0;
          end;
        end;
      end;
    end;
  end;
end;

Damit kannst Du einfach mal ein paar Terme ausprobieren, und Dir im Einzelschritt mal ansehen, was passiert.

[MarquiseDeSade]

Hallo :-D

Vielen Dank für deine ausführliche Erklärung Christian :thumb:

Eine Sache ist mir aber noch unklar und zwar....

Delphi-Quellcode:

if pos('+',AsTerm) > 0 then
begin 
    sLinks  := trim(copy(AsTerm,1,pos('+',AsTerm)-1)); 
     sRechts := trim(copy(AsTerm,pos('+',AsTerm)+1,MaxInt)); 
      Result  := Calculate(sLinks) + Calculate(sRechts);

Sobald bei der If-Abfrage ein Wert größer 0 ausgegeben wird(was ja der Fall ist, wenn im Sring ein "+" vorkommt) folgt die "copy-funktion" beginnend bei 1. Nun stellt sich für mich die Frage, was denn passiert, wenn die Aufgabe lauten würde: 2*2+22 ??? Würde dann nicht der Teilstring mit dem 2*2 mitkopiert??

In der Praxis wohl nicht, denn die Funktion Calculate funktioniert in meinem Rechner einwandfrei.

Wo ist mein Denkfehler??

In wieweit müsste man die Funktion verändern, um auch mit negativen Vorzeichen rechnen zu können?

gruß tobias

[sirius]

Du rufst also "calculate('2*2+22')" auf:

Die Funktion zerlegt den Term in 2*2 und in 22 ,addirt die beiden Terme (4+22) und ist fertig. Und woher kommt die 4?
Er ruft ja mit beiden Teilstrings ('2*2' und '22') erneut die Funktion calculate auf, also quasi sich selber. Das ist rekursiver Funktionsaufruf. Du musst dir also vorstellen es gibt unendlich viele Funktionen namens calculate und alle machen dasselbe.

Beim zweiten Aufruf con calculate wird jetzt nur noch '2*2' übergeben. Hier rennt das Programm dann eben bis zur If-Bedingung mit dem pos('*',AsTerm), weil er ein "*" findet, rechnet das aus, bekommt ne 4 und gibt diese zurück an die erste Funktion (Instanz) von calculate. Die erste Instanz hat jetzt also seine 4.

[MarquiseDeSade]

Ahhhh :stupid:

Ok, nun wird einiges klarer. Vielen Dank.

[sirius]

Und nicht vergessen (das habe ich, um Verwirrung zu vermeiden) gerade noch herausgelassen:

Auch die 22 (und später noch die beiden 2en) sind ja erstmal noch strings mit denen man nicht rechnen kann.

Deswegen werden auch sie an eine weitere Instanz von calculate übergeben. Und wenn calculate nur eine Zahl bekommt(Aufruf: calculate('22')) dann rennt er in den if-Bedingungen bis "result:=strtofloat(...) durch und gibt einfach die Zahl zurück ohne noch eine Instanz vom calculate aufzurufen. Ist ja dann auch nicht mehr nötig.

Edit: Und um mit Vorzeichen und Klammern etc. zu rechnen schau dir doch nochmal den Link von mir an. Ist genau dasselbe nur das die Funktions und Variablennamen anders sind.