Bedingung vereinfachen / leere cin-Eingabe auswerten

Ah natürlich, dieses kleine Fehlerchen ist mir bisher noch gar nicht aufgefallen..

Hört sich kompliziert an, aber dann werd ich mir das mal anschauen!

Plattformabhängig? Bedeutet?
Ja, das mit goto habe ich bereits im Forum gelesen, aber was kann ich anstelle dessen verwenden?

Bitmapper

helloworldc++ schrieb:

Plattformabhängig? Bedeutet?

system("cls") funktioniert z.B. nur unter Windows

helloworldc++ schrieb:

Ja, das mit goto habe ich bereits im Forum gelesen, aber was kann ich anstelle dessen verwenden?

Eine (do)-while Schleife

Bitmapper schrieb:

system("cls") funktioniert z.B. nur unter Windows

Achso ok, aber das stört mich nicht.

Bitmapper schrieb:

Eine (do)-while Schleife

Ist doch aber viel komplizierter..

Bitmapper schrieb:

if ((rz2 == '*' || rz2 == '/'))
         ergebnis = calc(zahl1, calc(zahl2, zahl3, rz2), rz1); 
       else 
         ergebnis = calc(calc(zahl1, zahl2, rz1), zahl3, rz2);
Das ist nicht ganz richtig, wenn rz2 punkt ist, aber rz1 auch dann muss rz1 trotzdem vor rz2 ausgewertet.
Ich verweise mal hierauf:
https://www.c-plusplus.net/forum/336688

Ohje damit hast mich jetzt völlig aus der Bahn geworfen...

Hab ewig daran rumgemacht, bis mir aufgefallen ist, dass es völlig egal ist, in welcher Reihenfolge multipliziert wird, da immer das gleiche rauskommt. Man nennt das auch Assoziativgesetz der Multiplikation

SG1

Ja, aber das gilt nicht für die Division.

Bitmapper

Das hier ist noch nicht schlimm, aber spätestens wenn verschachtelte Schleifen benötigt werden wird's mit goto sehr hässlich.

Hier mal eine Gegenüberstellung, es wird ein Feld auf dem Bildschirm ausgegeben:

#include <iostream>

// Gibt ein Feld auf dem Bildschirm aus
int main()
{
    int field[10][10] = { {0, 1, 2, 3, 4, 5, 6, 7, 8, 9},
                          {10,11,12,13,14,15,16,17,18,19},
                          {20,21,22,23,24,25,26,27,28,29},
                          {30,31,32,33,34,35,36,37,38,39},
                          {40,41,42,43,44,45,46,47,48,49},
                          {50,51,52,53,54,55,56,57,58,59},
                          {60,61,62,63,64,65,66,67,68,69},
                          {70,71,72,73,74,75,76,77,78,79},
                          {80,81,82,83,84,85,86,87,88,89},
                          {90,91,92,93,94,95,96,97,98,99} };
    int i, j = 0;

    start:;
    i = 0;
    start2:;
    std::cout << field[j][i] << ' ';
    i++;
    if (i > 9)
        goto start2_ende;
    else goto start2;

    start2_ende:;
    std::cout << '\n';
    j++;
    if (j < 10)
        goto start;
}

vs

#include <iostream>

// Gibt ein Feld auf dem Bildschirm aus
int main()
{
    int field[10][10] = { {0, 1, 2, 3, 4, 5, 6, 7, 8, 9},
                          {10,11,12,13,14,15,16,17,18,19},
                          {20,21,22,23,24,25,26,27,28,29},
                          {30,31,32,33,34,35,36,37,38,39},
                          {40,41,42,43,44,45,46,47,48,49},
                          {50,51,52,53,54,55,56,57,58,59},
                          {60,61,62,63,64,65,66,67,68,69},
                          {70,71,72,73,74,75,76,77,78,79},
                          {80,81,82,83,84,85,86,87,88,89},
                          {90,91,92,93,94,95,96,97,98,99} };

    for (int j = 0; j < 10; j++)
    {
        for (int i = 0; i < 10; i++)
            std::cout << field[j][i] << ' ';
        std::cout << '\n';
    }
}

Und, was meinst du ?

helloworldc++ schrieb:

Hab ewig daran rumgemacht, bis mir aufgefallen ist, dass es völlig egal ist, in welcher Reihenfolge multipliziert wird, da immer das gleiche rauskommt. Man nennt das auch Assoziativgesetz der Multiplikation

Bei der Multiplikation schon, aber bei: 3/3*4 ist es z.B wichtig, dass das erste zuerst ausgewertet wird.

Bitmapper schrieb:

Das hier ist noch nicht schlimm, aber spätestens wenn verschachtelte Schleifen benötigt werden wird's mit goto sehr hässlich.

Hier mal eine Gegenüberstellung, es wird ein Feld auf dem Bildschirm ausgegeben:

Danke!

Bitmapper schrieb:

Und, was meinst du ?

Bei der Multiplikation schon, aber bei: 3/3*4 ist es schon wichtig, dass das erste zuerst ausgewertet wird.

Na dann rechne mal:
3/3=1 14=4
34=12 12/3=4
:p

SG1

Das Kommutativgesetz gilt bei der Division natürlich auch nicht.

Bitmapper

3/3*4:

3/3 = 1
1*4 = 4

vs

3*4 = 12
3/12 = 0,25

HarteWare

Was passiert, wenn ich mich vertippe und ausversehen 5#6 eingebe?

Bitmapper

Ich habe mal etwas rumgefrickelt, das hier nimmt eine Rechnung von bis zu anzahl Operatoren:

#include <iostream>

double calc(double v1, double v2, char op);
int const anzahl = 19;

int main()
{
    double v[anzahl+1] = { 0 };
    char op[anzahl]  = { 0 };
    double ergebnis = 0;

    std::cout << "Welche Rechenaufgabe wollen sie loesen?" << std::endl;

    int i;
    std::cin >> v[0];
    for (i = 1; i < anzahl+1; i++)
    {
        if (std::cin >> op[i-1])
        {
            if (!(std::cin >> v[i]))
            {
                std::cout << "Fehler, ein Operator zu viel!" << std::endl;
                return 0;
            }
        }
        else
        {
            i--;
            break;
        }
    }

    if (i == 0)
    {
        std::cout << "Ungueltige Rechenaufgabe!" << std::endl;
        return 0;
    }
    if (i == anzahl+1) i = anzahl;

    for (int j = 0; j < i; j++)
    {
        if (op[j] == '*' || op[j] == '/')
        {
            v[j+1] = calc(v[j], v[j+1], op[j]);
            v[j] = 0;

            if (j > 0 && (op[j-1] == '-'))
                op[j] = '-';
            else
                op[j] = '+';
        }
    }

    int j;
    for (j = 0; j < i; j++)
    {
        v[j+1] = calc(v[j], v[j+1], op[j]);
    }
    ergebnis = v[j];

    std::cout << "Ergebnis:" << ergebnis << std::endl;
}

double calc(double v1, double v2, char op)
{
    switch (op)
    {
        case '+':
            return v1 + v2;
            break;
        case '-':
            return v1 - v2;
            break;
        case '*':
            return v1 * v2;
            break;
        case '/':
            return v1 / v2;
            break;
        default:
            {
                //Fehler
            }
    }
    return 0;
}

Wenn du eine Rechnung von weniger als anzahl Operatoren berechnen willst, kannst du die Schleife mit Strg+Z (unter Windows) beenden.
Der nächste Schritt wäre dann alles dynamisch zu machen, also beliebig viele Operatoren zu akzeptieren.
Edit: Fehler gefixt.