Rechenvorschriften beachten.

[Evian]

Hallo,

ich habe eine Frage zu C++, aber eigentlich könnte könnte man das Problem auch in jeder anderen belibigen Programmiersprache behandeln. Also ich habe follgende Aufgabenstellung:

--------
Es wird eine Rechenaufgabe der Form: a + b in die TextBox eingetragen (Grundrechenarten).
Nach betätigen des Buttons soll das Ergebnis in der Form a + b = c in der gleichen TextBox
ausgegeben werden, a, b, c sind Gleitpunktzahlen.

Zusatzaufgabe: Die Rechnung besteht aus beliebig vielen Operanten.
--------

Bis jetzt haben ich das durch follgenden Quelltext gelöst, der linear durch den Stringgeht, die Zahlen zwichen den Operatoren ausließt und sie dann anhand der Operatoren zusammenrechnet.

Code:

private: System::Void btnOk3_Click(System::Object *  sender, System::EventArgs *  e)
       {
         int anf=0,i;
         double erg=0;
         char oper='+';
         String* Zahl;
         for(i=0;i<tbxAufgabe3->Text->Length;i++){
            if((tbxAufgabe3->Text->Chars[i]=='+')||(tbxAufgabe3->Text->Chars[i]=='-')||(tbxAufgabe3->Text->Chars[i]=='*')||(tbxAufgabe3->Text->Chars[i]=='/')||(i == tbxAufgabe3->Text->Length-1)){
               if(i == tbxAufgabe3->Text->Length-1){
                  Zahl =   tbxAufgabe3->Text->Substring(anf,i-anf+1);
               }else{
                  Zahl =   tbxAufgabe3->Text->Substring(anf,i-anf);
               }
               
               switch(oper){
                  case '+': erg=erg+Convert::ToDouble(Zahl); break;
                  case '-': erg=erg-Convert::ToDouble(Zahl); break;
                  case '*': erg=erg*Convert::ToDouble(Zahl); break;   
                  case '/': erg=erg/Convert::ToDouble(Zahl); break;
               }
                  oper = tbxAufgabe3->Text->Chars[i];
                  anf = i+1;
            }
         }
         tbxAufgabe3->Text = String::Concat(tbxAufgabe3->Text,"=",Convert::ToString(erg));
         
       }

Funktioniert soweit auch ganz gut, nur wird dabei nicht beachtet, dass man Punktrechnungen vor Strichrechnungen machen muss. Hat jemand eine Idee, wie ich das am Besten angehen könnte?!

gruß

Evian

Edit: Wenn jemand die Lösung kennt, sie aber nur in Object Pascal angeben könnte, dann würde mir das schon reichen.

[JasonDX]

Auf die Schnelle faellt mir eine Aufteilung in 2 Schleifen ein:
Beide gehen nachwievor vom ersten Zeichen bis zum letzten, jedoch: in der ersten Schleife beachtest du nur die Punkt-Rechenarten, also * und /.
In der zweiten Schleife rechnst du die restlichen Operatoren aus, also + und -.
Die Schleifen sehen zwar ziemlich redundant aus, und es gaebe sicherlich schoenere Loesungen, aber dies ist mal die einfachste, die mir in den Kopf kommt.

greetz
Mike

PS: Wir ham auch C-Quellcode Tags: [c][/c]

[Evian]

Na die Idee ist schon mal ganz nice.. werd das morgen mal ausprobieren und dann berichten

[webcss]

Also ich habe dieses Problem (in Delphi) so gelöst, Stichwort: Rekursion.

Delphi-Quellcode:

Function TFloatEdit.Evaluate(AValue: String) : extended;
var
   sop1, sop2: string;
   op1, op2  : extended;
   func : char;
   i    : integer;
   done : boolean;
begin
   sop2 := trim(AValue);
   if sop2 = '' then sop2 := '0';
   done := false;
   // Addition + Subtraktion
   i := Length(sop2);
   while (i > 2) and not done do begin
      if sop2[i] in ['+', '-'] then begin
         sop1 := copy(sop2, 1, pred(i));
         func:= sop2[i];
         delete(sop2, 1, i);

         op1 := Evaluate(sop1);
         op2 := Evaluate(sop2);
         case func of
            '+': Result := op1 + op2;
            '-': Result := op1 - op2;
         end;
         done := true;
      end;
      dec(i);
   end;
   // Multiplikation u. Division
   i := 2;
   while (i < Length(sop2)) and not done do begin
      if sop2[i] in ['*', '/'] then begin
         sop1 := copy(sop2, 1, pred(i));
         func:= sop2[i];
         delete(sop2, 1, i);

         op1 := Evaluate(sop1);
         op2 := Evaluate(sop2);
         case func of
            '*': Result := op1 * op2;
            '/': Result := op1 / op2;
         end;
         done := true;
      end;
      inc(i);
   end;
   // Keine weitere Operation
   if not done then
      Result := StrToFloat(sop2);
end;

[Flo85]

Zitat von webcss:

Also ich habe dieses Problem (in Delphi) so gelöst, Stichwort: Rekursion.

Am besten kann man das mit Rekursion lösen
Die eingabe must du aufteilen.

als erstes die strich und danach die punktrechenarten wegen punkt vor strich.

bsp:

3+4*7-9

Aufteilen in

"3" + "4*7-9"

"4*7" - "9"


"4" * "7"

also genau wie es webcss im quelltext hat.



wenn jetzt noch klammern dazu kommen würden müstest du prüfen ob du in einer klammer bist bevor du zerlegst
d.h. du zählst die aufgehenden und die zugehenden

bsp:

(3+4)*7-9

"(3+4)*7" - "9"

"(3+4)" * "7"

"(3+4)" -> "3+4"

"3" + "4"

[marabu]

Herzlich willkommen in der Delphi-PRAXiS, Flo85.

Ich würde es ohne Rekursion versuchen, solange die Ausdrücke noch so einfach sind:

Ein Summand ist entweder eine (vorzeichenbehaftete) Zahl oder ein Ausdruck.
Ein Ausdruck verwendet nur die Operatoren "*" und "/".

Delphi-Quellcode:

// Summanden werden eingekellert, wobei 
// Ausdrücke sofort reduziert werden.

function Eval(var s: String; stack: TStack): Boolean;
var
  cOperator: Char;
  bInvert: Boolean;
begin
  Result := GetOperand(s, stack);
  while Result do
    if s = '' then
    begin
      while stack.Size > 1 do
        stack.Push(stack.Pop + stack.Pop);
      Exit;
    end else
    begin
      Result := GetOperator(s, cOperator);
      if Result then
      begin
        bInvert := cOperator = '-';
        Result := GetOperand(s, stack);
        if Result then
        begin
          if bInvert then
            stack.Push(- stack.Pop);
          case cOperator of
            '*': stack.Push(stack.Pop * stack.Pop);
            '/': stack.Push(1 / stack.Pop * stack.Pop);
          end;
        end
      end;
    end;
end;

Freundliche Grüße vom marabu