"Rechner" gibt falsches Ergebnis aus



  • Moin, (ich möchte mich entschuldigen, falls dies das falsche Forum ist)
    Ich bin momentan dabei einen simplen Rechner zu programmieren (Ich programmiere noch nicht allzu lange und bin auch noch nicht so wirklich geübt). Dafür habe ich jetzt mit switches für die einzelnen Operanten gearbeitet (Ich weiß es wird eine elegantere Option geben, die ich nicht kenne). Als ich ihn dann Testen wollte, gab er aber leider ein völlig falsches Ergebnis aus, wo ich auch nicht weiß wie er darauf kommt. Als test hatte ich 6 + 5 * 3 / 7 - 4 verwendet, es wurde aber 141 ausgegeben, was schließcih einfach fasch ist. Kann mir jemand helfen, ich finde einfach keinen Fehler? : ( Schonmal danke im voraus an alle die mir helfen : )

     cout << "Zahl 1: "; cin >> a1; cout << endl; // ist nur ein ausschnitt
                cout << "Operator 1 (+,-,*,/, ^ [Wurzeln als x ^ (1/n) schreiben]): "; cin >> a; cout << endl;
                cout << "Zahl 2: "; cin >> b1; cout << endl;
                cout << "Operator 2: "; cin >> b; cout << endl;
                cout << "Zahl 3: "; cin >> c1; cout << endl;
                cout << "Operator 3: "; cin >> c; cout << endl;
                cout << "Zahl 4: "; cin >> d1; cout << endl;
                cout << "Operator 4: "; cin >> d; cout << endl;
                cout << "Zahl 5: "; cin >> e1; cout << endl;
                switch (a)
                {
                case '+':
                    switch (b)
                    {
                    case '+':
                        switch (c)
                        {
                        case '+':
                            switch (d)
                            {
                            case '+':
                                x = a1 + b1 + c1 + d1 + e1;
                                break;
                            case '-':
                                x = a1 + b1 + c1 + d1 - e1;
                                break;
                            case '*':
                                x = a1 + b1 + c1 + d1 * e1;
                                break;
                            case '/':
                                x = a1 + b1 + c1 + d1 / e1;
                                break;
                            case '^':
                                x = a1 + b1 + c1 + pow(d1,e1);
                                break;
                            }
                        case '-':
                            switch (d)
                            {
                            case '+':
                                x = a1 + b1 + c1 - d1 + e1;
                                break;
                            case '-':
                                x = a1 + b1 + c1 - d1 - e1;
                                break;
                            case '*':
                                x = a1 + b1 + c1 - d1 * e1;
                                break;
                            case '/':
                                x = a1 + b1 + c1 - d1 / e1;
                                break;
                            case '^':
                                x = a1 + b1 + c1 - pow(d1, e1);
                                break;
                            }
                        case '*':
                            switch (d)
                            {
                            case '+':
                                x = a1 + b1 + c1 * d1 + e1;
                                break;
                            case '-':
                                x = a1 + b1 + c1 * d1 - e1;
                                break;
                            case '*':
                                x = a1 + b1 + c1 * d1 * e1;
                                break;
                            case '/':
                                x = a1 + b1 + c1 * d1 / e1;
                                break;
                            case '^':
                                x = a1 + b1 + c1 * pow(d1, e1);
                                break;
                            }
                        case '/':
                            switch (d)
                            {
                            case '+':
                                x = a1 + b1 + c1 / d1 + e1;
                                break;
                            case '-':
                                x = a1 + b1 + c1 / d1 - e1;
                                break;
                            case '*':
                                x = a1 + b1 + c1 / d1 * e1;
                                break;
                            case '/':
                                x = a1 + b1 + c1 / d1 / e1;
                                break;
                            case '^':
                                x = a1 + b1 + c1 / pow(d1,e1);
                                break;
                            }
                        case '^':
                            switch (d)
                            {
                            case '+':
                                x = a1 + b1 + pow(c1,d1) + e1;
                                break;
                            case '-':
                                x = a1 + b1 + pow(c1,d1) - e1;
                                break;
                            case '*':
                                x = a1 + b1 + pow(c1,d1) * e1;
                                break;
                            case '/':
                                x = a1 + b1 + pow(c1,d1) / e1;
                                break;
                            case '^':
                                x = a1 + b1 + pow(c1,pow(d1, e1));
                                break;
                            }
                        }
                        break;
                    case '-':
                        switch (c)
                        {
                        case '+':
                            switch (d)
                            {
                            case '+':
                                x = a1 + b1 - c1 + d1 + e1;
                                break;
                            case '-':
                                x = a1 + b1 - c1 + d1 - e1;
                                break;
                            case '*':
                                x = a1 + b1 - c1 + d1 * e1;
                                break;
                            case '/':
                                x = a1 + b1 - c1 + d1 / e1;
                                break;
                            case '^':
                                x = a1 + b1 - c1 + pow(d1, e1);
                                break;
                            }
                        case '-':
                            switch (d)
                            {
                            case '+':
                                x = a1 + b1 - c1 - d1 + e1;
                                break;
                            case '-':
                                x = a1 + b1 - c1 - d1 - e1;
                                break;
                            case '*':
                                x = a1 + b1 - c1 - d1 * e1;
                                break;
                            case '/':
                                x = a1 + b1 - c1 - d1 / e1;
                                break;
                            case '^':
                                x = a1 + b1 - c1 - pow(d1, e1);
                                break;
                            }
                        case '*':
                            switch (d)
                            {
                            case '+':
                                x = a1 + b1 + c1 * d1 + e1;
                                break;
                            case '-':
                                x = a1 + b1 + c1 * d1 - e1;
                                break;
                            case '*':
                                x = a1 + b1 + c1 * d1 * e1;
                                break;
                            case '/':
                                x = a1 + b1 + c1 * d1 / e1;
                                break;
                            case '^':
                                x = a1 + b1 + c1 * pow(d1, e1);
                                break;
                            }
                        case '/':
                            switch (d)
                            {
                            case '+':
                                x = a1 + b1 + c1 / d1 + e1;
                                break;
                            case '-':
                                x = a1 + b1 + c1 / d1 - e1;
                                break;
                            case '*':
                                x = a1 + b1 + c1 / d1 * e1;
                                break;
                            case '/':
                                x = a1 + b1 + c1 / d1 / e1;
                                break;
                            case '^':
                                x = a1 + b1 + c1 / pow(d1, e1);
                                break;
                            }
                        case '^':
                            switch (d)
                            {
                            case '+':
                                x = a1 + b1 + pow(c1, (d1 + e1));
                                break;
                            case '-':
                                x = a1 + b1 + pow(c1,(d1 - e1));
                                break;
                            case '*':
                                x = a1 + b1 + pow(c1, (d1 * e1));
                                break;
                            case '/':
                                x = a1 + b1 + pow(c1,(d1 / e1));
                                break;
                            case '^':
                                x = a1 + b1 + pow(c1, pow(d1, e1));
                                break;
                            }
                        }
                        break;
                    case '*':
                        switch (c)
                        {
                        case '+':
                            switch (d)
                            {
                            case '+':
                                x = a1 + b1 * c1 + d1 + e1;
                                break;
                            case '-':
                                x = a1 + b1 * c1 + d1 - e1;
                                break;
                            case '*':
                                x = a1 + b1 * c1 + d1 * e1;
                                break;
                            case '/':
                                x = a1 + b1 * c1 + d1 / e1;
                                break;
                            case '^':
                                x = a1 + b1 * c1 + pow(d1, e1);
                                break;
                            }
                        case '-':
                            switch (d)
                            {
                            case '+':
                                x = a1 + b1 * c1 - d1 + e1;
                                break;
                            case '-':
                                x = a1 + b1 * c1 - d1 - e1;
                                break;
                            case '*':
                                x = a1 + b1 * c1 - d1 * e1;
                                break;
                            case '/':
                                x = a1 + b1 * c1 - d1 / e1;
                                break;
                            case '^':
                                x = a1 + b1 * c1 - pow(d1, e1);
                                break;
                            }
                        case '*':
                            switch (d)
                            {
                            case '+':
                                x = a1 + b1 * c1 * d1 + e1;
                                break;
                            case '-':
                                x = a1 + b1 * c1 * d1 - e1;
                                break;
                            case '*':
                                x = a1 + b1 * c1 * d1 * e1;
                                break;
                            case '/':
                                x = a1 + b1 * c1 * d1 / e1;
                                break;
                            case '^':
                                x = a1 + b1 * c1 * pow(d1, e1);
                                break;
                            }
                        case '/':
                            switch (d)
                            {
                            case '+':
                                x = a1 + b1 * c1 / d1 + e1;
                                break;
                            case '-':
                                x = a1 + b1 * c1 / d1 - e1;
                                break;
                            case '*':
                                x = a1 + b1 * c1 / d1 * e1;
                                break;
                            case '/':
                                x = a1 + b1 * c1 / d1 / e1;
                                break;
                            case '^':
                                x = a1 + b1 * c1 / pow(d1, e1);
                                break;
                            }
    


  • @chritzeltopf sagte in "Rechner" gibt falsches Ergebnis aus:

    Kann mir jemand helfen

    Kaum. Das Programm ist unvollständig. Die Stelle mit der Ausgabe zeigst du nicht.

    Benutze einen Debugger und schau nach, was das Programm macht.



  • Ein Hilf wäre schon mal. vor dem switch (a) die ganze Eingabe mal wieder zur Kontrolle auszugeben.

    Wenn du den Debugger noch nicht magst, dann baue noch ein paar cout mittendrin rein.
    Z.B hinter jedem case '+' gleich ein cout << '+';



  • @chritzeltopf sagte in "Rechner" gibt falsches Ergebnis aus:

    x = a1 + b1 * c1 / d1 + e1;

    Generell: was machst du, wenn jemand noch eine Opration mehr machen will oder eine weniger? Du wiederholst dich da leider furchtbar, sodass du von Zeile 10 bis 293 praktisch immer denselben Code wiederholst - nur mir anderen Rechenzeichen. Das ist fehleranfällig.

    Compiliere außerdem mit Warnungen (bei gcc bitte -Wall -Wextra angeben! Immer! Wichtig!), dir fehlen elf break;. Das ist vermutlich auch schon der Fehler (wenn man vom Stil absieht). Der Compiler sagt dir auch genau, wo die fehlen. Du musst ihm nur sagen, dass du Warnungen haben willst.



  • @chritzeltopf da fehlen aber einige break, das erste nach Zeile 36.



  • @wob danke, das hilft vermutlich schon viel. Wie lass ich mir das fehlende break in Visual Studio anzeigen 😅
    und was bedeutet "bei gcc bitte -Wall -Wextra angeben! Immer! Wichtig!" (sorry, hab aber keine Ahnung 😅



  • Siehe hier: https://docs.microsoft.com/de-de/cpp/build/reference/compiler-option-warning-level?view=msvc-160

    Wenn du nicht Visual Studio verwenden würdest, wäre die Chance hoch gewesen, dass du gcc oder clang verwendest, das sind alternative Compiler, die auf Nicht-Windows-Plattformen sehr verbreitet sind. Unter Windows bist du mit Visual Studio aber gut aufgestellt. Dort heißt es dann eben /W<level> - siehe obigen Link.



  • @manni66 sagen wir es so, ich wollte jetzt keine 3000 zeilen code hier rein schicken. Da ich wie gesagt keine elegantere Methode kenne, hab cih für jede anzahl Zahlen von 2-5 bislang diese switch verschachtelungen



  • @wob halt mich gerne für doof, aber wo muss ich das eingeben😅



  • @chritzeltopf sagte in "Rechner" gibt falsches Ergebnis aus:

    @wob halt mich gerne für doof, aber wo muss ich das eingeben😅

    Das steht doch auf der Seite beschrieben, hast du den Absatz "So legen Sie die Compileroptionen in der Visual Studio-Entwicklungsumgebung fest" gefunden? Ansonsten kann ich dir nicht weiterhelfen, da ich normalerweise nicht unter Windows arbeite und VS nicht kenne.

    Stelle /W4 ein und ggf. auch /WX



  • @wob ooops....



  • @wob ok hab ich jetzt tatsächlich doch geschafft, aber mir werden keine fehlenden break;s angezeigt ?



  • Keine Ahnung, muss jemand, der mit VS arbeitet, beantworten. Mit gcc bekommst du die implicit-fallthrough-Warnung.

    Jedenfalls hast du die breaks zwar in den innersten switches jeweils drin, aber bei den äußeren nicht. Das wesentliche Problem ist, dass deine (äußeren) switches viel zu lang ist. Jeder case sollte nur 1 bis vielleicht 3 Zeilen lang sein. Wenn der Code länger ist, mach eine Funktion draus. Generell: Teile den Code in kurze (!) Funktionen auf, wo immer möglich.

    Aber jetzt such erstmal die fehlenden breaks und die Warnungseinstellung.

    PS: Es scheint, dass diese Warnung erst mit VS 16.7 eingeführt wurde: https://developercommunity.visualstudio.com/t/issue-compiler-warning-when-using-implicit-fallthr/423975



  • Wenn dein VS das nicht kann, schau mal hier:
    https://gcc.godbolt.org/z/111sdE



  • @wob danke, es lag wirklich einfach an den fehlenden break; Nochmals vielen Dank!
    Aber eine frage juckt mcih dann jetzt doch: Wie würde man das (grob) eleganter machen?



  • Lerne, was Schleifen und Funktionen sind (so daß das Programm dann auch für eine beliebige Anzahl von Operanden funktioniert) - dann wird der Code sogar kürzer und eleganter.



  • @chritzeltopf sagte in "Rechner" gibt falsches Ergebnis aus:

    Wie würde man das (grob) eleganter machen?

    Ich denke "Schleifen und Funktionen" ist ein bißchen sehr allgemein. Für dein Problem wäre wohl z.B. "Stack" ein bessees Stichwort. Weißt du was das ist?



  • Den Stack braucht man nur, wenn man die Operatorprioritäten auch umsetzen will, also z.B. bei Eingabe von 2+3*4 "Punkt vor Strich" gerechnet werden soll (anstatt jedesmal sofort den Operator anzuwenden).



  • @Th69 sagte in "Rechner" gibt falsches Ergebnis aus:

    anstatt jedesmal sofort den Operator anzuwenden - wie es der OP auch in seinem Code bisher macht

    Nein. x = a1 + b1 + c1 - d1 * e1;verlässt sich auf die C++ Regeln.



  • Habe ich auch gerade gesehen, daher habe ich es oben wegeditiert.

    Trotzdem sollte der OP ersteinmal den Code umschreiben...

    PS: Ich könnte ja jetzt meinen Mathe-Parser empfehlen, aber das hilft dem OP ja beim Lernen nicht ;-).


Log in to reply