Probleme beim Taschenrechner



  • Hallo leute,

    ich habe gerade angefangen C++ zu lernen und möchte gerne einen Windows Taschenrechner programmieren. Das Problem dabei ist, dass es nicht so einfach ist wie einer Console, dass ich 2 Zahlen eintippe und je nachdem welche Mathematische funktion aufgerufen wird, kriege ich auch das Ergebnis.

    Bei einem Windows Taschenrechner drücke ich ja auf Buttons und dadurch erhalte ich dann eine Zahl, sobald ich dann auf + oder - klicke, muss ja diese Zahl zwischengespeichert werden und eine Neue Zahl soll eingegeben werden. Und danach kann es ja durchaus sein, dass man nicht auf das = button drückt, sondern auch mal vom letzten ergebnis einen wert addieren will oder subtrahieren.

    Also ich habe es bis jetzt folgendermaßen umgesetzt:

    //---------------------------------------------------------------------------
    
    #include <vcl.h>
    #pragma hdrstop
    
    #include "Unit1.h"
    //---------------------------------------------------------------------------
    #pragma package(smart_init)
    #pragma resource "*.dfm"
    TForm1 *Form1;
    //---------------------------------------------------------------------------
    
    __fastcall TForm1::TForm1(TComponent* Owner)
            : TForm(Owner)
    {
    }
    //---------------------------------------------------------------------------
    AnsiString asWert;
    int typ = 0;
    bool isSet = false;
    
    void __fastcall TForm1::Zahl1Click(TObject *Sender)
    {
    asWert = asWert + "1";
    Edit1->Text = asWert;
    }
    //---------------------------------------------------------------------------
    void __fastcall TForm1::Zahl2Click(TObject *Sender)
    {
    asWert = asWert + "2";
    Edit1->Text = asWert;
    }
    //---------------------------------------------------------------------------
    void __fastcall TForm1::Zahl3Click(TObject *Sender)
    {
    asWert = asWert + "3";
    Edit1->Text = asWert;
    }
    //---------------------------------------------------------------------------
    void __fastcall TForm1::Zahl4Click(TObject *Sender)
    {
    asWert = asWert + "4";
    Edit1->Text = asWert;
    }
    //---------------------------------------------------------------------------
    void __fastcall TForm1::Zahl5Click(TObject *Sender)
    {
    asWert = asWert + "5";
    Edit1->Text = asWert;
    }
    //---------------------------------------------------------------------------
    void __fastcall TForm1::Zahl6Click(TObject *Sender)
    {
    asWert = asWert + "6";
    Edit1->Text = asWert;
    }
    //---------------------------------------------------------------------------
    void __fastcall TForm1::Zahl7Click(TObject *Sender)
    {
    asWert = asWert + "7";
    Edit1->Text = asWert;
    }
    //---------------------------------------------------------------------------
    void __fastcall TForm1::Zahl8Click(TObject *Sender)
    {
    asWert = asWert +"8";
    Edit1->Text = asWert;
    }
    //---------------------------------------------------------------------------
    void __fastcall TForm1::Zahl9Click(TObject *Sender)
    {
    asWert = asWert +"9";
    Edit1->Text = asWert;
    }
    //---------------------------------------------------------------------------
    void __fastcall TForm1::Zahl0Click(TObject *Sender)
    {
    asWert = asWert + "0";
    Edit1->Text = asWert;
    }
    //---------------------------------------------------------------------------
    double dZahl1;
    double dZahl2;
    double dErgebnis;
    
    void __fastcall TForm1::AddierenClick(TObject *Sender)
    {
    
    if(typ == 0){
    dErgebnis = StrToFloat (Edit1->Text);
     typ = 4;
    }else{
    dZahl1 = StrToFloat (Edit1->Text);
    typ = 4;
    calculate ();
    }
    
    //dErgebnis = dErgebnis + dZahl1;
    //Edit1->Text = FloatToStr (dErgebnis);
    asWert="";
    }
    //---------------------------------------------------------------------------
    void __fastcall TForm1::SubtrahierenClick(TObject *Sender)
    {
    
    if (typ == 0 ){
    dErgebnis = StrToFloat (Edit1->Text);
    typ = 3;
    }else{
    dZahl1 = StrToFloat (Edit1->Text);
    typ = 3;
    calculate ();
    }
    
    //dErgebnis = dErgebnis - dZahl1;
    //Edit1->Text = FloatToStr (dErgebnis);
    asWert ="";
    }
    //---------------------------------------------------------------------------
    void __fastcall TForm1::MultiplizierenClick(TObject *Sender)
    {
    calculate ();
    if (typ == 0 ){
    dErgebnis = StrToFloat (Edit1->Text);
    typ = 2;
    }else{
    dZahl1 = StrToFloat (Edit1->Text);
    
    }
    //dErgebnis = dErgebnis * dZahl1;
    //Edit1->Text = FloatToStr (dErgebnis);
    asWert ="";
    }
    //---------------------------------------------------------------------------
    void __fastcall TForm1::DividierenClick(TObject *Sender)
    {
    calculate ();
    if (typ ==0){
    dErgebnis = StrToFloat (Edit1->Text);
    typ = 1;
    }else{
    dZahl1 = StrToFloat (Edit1->Text);
    
    }
    //dErgebnis = dErgebnis / dZahl1;
    //Edit1->Text = FloatToStr (dErgebnis);
    asWert ="";
    }
    
    //---------------------------------------------------------------------------
    void __fastcall TForm1::KommaClick(TObject *Sender)
    {
    if(!isSet){
      asWert = asWert + "," ;
      isSet = true;
       Edit1->Text = asWert;
    }
    
    }
    //---------------------------------------------------------------------------
     int iCount = 0;
    void __fastcall TForm1::GleichheitszeichenClick(TObject *Sender)
    {
    
    calculate();
    if(iCount == 0){
    dZahl1 = StrToFloat (Edit1->Text);
    iCount++;
    }
    
    asWert ="";
    }
    
    //---------------------------------------------------------------------------
    void  calculate(){
    //
    switch(typ){
      case 4:{
           dErgebnis = dErgebnis + dZahl1;
           Form1->Edit1->Text = FloatToStr (dErgebnis);
           break;
     }
      case 3:{
           dErgebnis = dErgebnis - dZahl1;
           Form1->Edit1->Text = FloatToStr (dErgebnis);
           break;
     }
      case 2:{
           dErgebnis = dErgebnis * dZahl1;
           Form1->Edit1->Text = FloatToStr (dErgebnis);
           break;
     }
      case 1:{
           dErgebnis = dErgebnis / dZahl1;
           Form1->Edit1->Text = FloatToStr (dErgebnis);
           break;
      }
    }
    }
    

    vielen dank

    mfg Alex



  • Was genau ist nun das Problem? Treten Fehler auf?



  • Hallo

    Das Prinzip hast du schon korrekt beschrieben. Wenn du jetzt eine konkrete Frage hast, dann stell sie auch. "funktioniert nicht" ist keine konkrete Problembeschreibung.

    bis bald
    akari



  • Naja das Problem ist folgendes, im Windows Taschenrechner drücke ich auf die Buttons 1 und 0, dann steht da 10, danach drücke ich auf Addieren und dann tippe ich wieder 10 ein, als nächstes drücke ich auf - und kriege das ergebnis angezeigt also 20. Tippe ich die 5 ein und dann auf = , kriege ich 15 als ergebnis.

    Mein Taschenrechner verhält sich aber so:
    tippe ich 10 ein, danach auf + und dann wieder 10 , sehe ich dann die 10 im eingabefeld, und es müsste im Programm die 20 abgespeichert werden. Wenn ich danach auf - drücke, erhalte ich dann 0 weil ja irgendwie die 20 nicht gespeichert ist . also 10 + 10 dann - kriege ich 0 als ergebnis.

    es ist auf jedenfall irgendwo ein Logik fehler im Programm, ich weis nicht genau wann ich nun die Calculate() funktion aufrufen muss und wie ich am besten unterscheiden kann ob die zahl, die gerade eingetippt wird ,die erste zahl ist
    hier nochmal die rechnung: 10 + 10 - 5 = 15 (ich komme nur bis 10 + 10 - weil wen ich - eingebe bekomme ich als ergebnis 0) 😕



  • du rechnest momentan so:
    10+ -> ergibt 10
    10-10 -> ergibt 0
    0-10= -> ergibt -10 --> obwohl du 5 eingegeben hast, aber das calculate() steht zuerst

    du willst aber:
    10+10 -> ergibt 20
    20-5 -> ergibt 15

    das Problem ist, dass du das aktuelle Formelzeichen mit der vorhergehenden Zahl verwendest und nicht wie üblich die vorhergehende Zahl und das vorhergehenden Formelzeichen mit der aktuellen Zahl. du mußt dir also etwas mehr merken: immer 2 Zahlen und ein Formelzeichen und erst danach darfst du dir das gerade angegebene Formelzeichen mit dem Ergebnis merken und so weiter



  • So nur nebenbei am Rande

    Probier es doch mal mit dem Prinzip der Umgekehrten Polnischen Notation.

    Du hast einen Stack auf den du erst mal zwei Zahlen schiebst und danach den operator angibst. die zahlen werden zusammengerechnet und der stack auf das ergebnis reduziert.
    dann gibst du die nächste zahl in den stack und wieder einen operator an. immer das gleiche system.
    Ich fand es damals auf dem Prinzip leichter einen Taschenrechner zu schreiben.


Log in to reply