So strukturieren Sie eine Schleife, die sich bis zum Erfolg wiederholt und Fehler behandelt

Ich bin ein Autodidakt. Ich habe vor ungefähr 1,5 Jahren angefangen zu programmieren. Jetzt habe ich angefangen, Programmierunterricht in der Schule zu haben. Wir haben Programmierkurse für 1/2 Jahr und werden jetzt noch 1/2 haben.

In den Klassen lernen wir, in C ++ zu programmieren (eine Sprache, die ich bereits gut kannte, bevor wir anfingen).

Ich hatte während dieses Kurses keine Schwierigkeiten, aber es gibt ein wiederkehrendes Problem, für das ich keine klare Lösung finden konnte.

Das Problem ist wie folgt (im Pseudocode):

 do something
 if something failed:
     handle the error
     try something (line 1) again
 else:
     we are done!

Hier ist ein Beispiel in C ++

Der Code fordert den Benutzer auf, eine Nummer einzugeben, bis die Eingabe gültig ist. Hiermit wird cin.fail()überprüft, ob die Eingabe ungültig ist. Wann cin.fail()ist truemuss ich anrufen cin.clear()und der cin.ignore()Lage sein, weiterhin eine Eingabe von dem Strom zu bekommen.

Mir ist bekannt, dass dieser Code nicht überprüft EOF. Von den Programmen, die wir geschrieben haben, wird nicht erwartet, dass sie dies tun.

So habe ich den Code in einer meiner Aufgaben in der Schule geschrieben:

for (;;) {
    cout << ": ";
    cin >> input;
    if (cin.fail()) {
        cin.clear();
        cin.ignore(512, '\n');
        continue;
    }
    break;
}

Mein Lehrer sagte, dass ich das nicht benutzen sollte breakund continuemag. Er schlug vor, stattdessen eine reguläre Schleife whileoder eine do ... whileSchleife zu verwenden.

Es scheint mir, dass die Verwendung von breakund continueder einfachste Weg ist, diese Art von Schleife darzustellen. Ich habe tatsächlich eine ganze Weile darüber nachgedacht, aber nicht wirklich eine klarere Lösung gefunden.

Ich denke, er wollte, dass ich so etwas mache:

do {
    cout << ": ";
    cin >> input;
    bool fail = cin.fail();
    if (fail) {
        cin.clear();
        cin.ignore(512, '\n');
    }
} while (fail);

Für mich scheint diese Version viel komplexer zu sein, da wir jetzt auch eine Variable haben, die aufgerufen wird fail, um den Überblick zu behalten, und die Überprüfung auf Eingabefehler zweimal statt nur einmal durchgeführt wird.

Ich dachte mir auch, dass ich den Code so schreiben kann (Missbrauch der Kurzschlussauswertung):

do {
    cout << ": ";
    cin >> input;
    if (fail) {
        cin.clear();
        cin.ignore(512, '\n');
    }
} while (cin.fail() && (cin.clear(), cin.ignore(512, '\n', true);

Diese Version funktioniert genau wie die anderen. Es wird nicht verwendet breakoder continueund der cin.fail()Test wird nur einmal durchgeführt. Es erscheint mir jedoch nicht richtig, die "Kurzschlussbewertungsregel" so zu missbrauchen. Ich glaube auch nicht, dass es meinem Lehrer gefallen würde.

Dieses Problem betrifft nicht nur die cin.fail()Überprüfung. Ich habe breakund continuemag dies für viele andere Fälle, in denen ein Satz von Codes wiederholt wird, bis eine Bedingung erfüllt ist, bei der auch etwas getan werden muss, wenn die Bedingung nicht erfüllt ist (wie das Aufrufen cin.clear()und cin.ignore(...)aus dem cin.fail()Beispiel).

Ich habe breakund continuewährend des gesamten Kurses weiter verwendet und jetzt hat mein Lehrer aufgehört, sich darüber zu beschweren.

Was ist deine Meinung dazu?

Glaubst du, mein Lehrer hat recht?

Kennen Sie einen besseren Weg, um diese Art von Problem darzustellen?

Ich würde die if-Anweisung etwas anders schreiben, also wird sie genommen, wenn die Eingabe erfolgreich ist.

for (;;) {
    cout << ": ";
    if (cin >> input)
        break;
    cin.clear();
    cin.ignore(512, '\n');
}

Es ist auch kürzer.

Was auf einen kürzeren Weg hindeutet, der Ihrem Lehrer gefallen könnte:

cout << ": ";
while (!(cin >> input)) {
    cin.clear();
    cin.ignore(512, '\n');
    cout << ": ";
}

Was Sie anstreben müssen, ist die Vermeidung von Rohschleifen .

Verschieben Sie die komplexe Logik in eine Hilfsfunktion, und plötzlich sind die Dinge viel klarer:

bool getValidUserInput(string & input)
{
    cout << ": ";
    cin >> input;
    if (cin.fail()) {
        cin.clear();
        cin.ignore(512, '\n');
        return false;
    }
    return true;
}

int main() {
    string input;
    while (!getValidUserInput(input)) { 
        // We wait for a valid user input...
    }
}

Es ist nicht so sehr for(;;)schlecht. Es ist einfach nicht so klar wie Muster wie:

while (cin.fail()) {
    ...
}

Oder wie Sjoerd es ausdrückte:

while (!(cin >> input)) {
    ...
}

Betrachten wir das primäre Publikum für dieses Zeug als Ihre Programmierkollegen, einschließlich der zukünftigen Version von Ihnen, die sich nicht mehr daran erinnert, warum Sie die Pause am Ende so durchgehalten oder die Pause mit dem Fortfahren übersprungen haben. Dieses Muster aus Ihrem Beispiel:

for (;;) {
    ...
    if (blah) {
        continue;
    }
    break;
}

... erfordert ein paar Sekunden zusätzlichen Denkens, um im Vergleich zu anderen Mustern zu simulieren. Es ist keine feste Regel, aber das Überspringen der break-Anweisung mit dem Fortsetzen fühlt sich chaotisch oder klug an, ohne nützlich zu sein, und das Setzen der break-Anweisung am Ende der Schleife, selbst wenn es funktioniert, ist ungewöhnlich. Normalerweise werden beide breakund continueverwendet, um die Schleife oder diese Iteration der Schleife vorzeitig zu evakuieren, sodass es sich etwas seltsam anfühlt, wenn Sie am Ende eine der beiden Schleifen sehen, auch wenn dies nicht der Fall ist.

Davon abgesehen gute Sachen!

Mein Logiklehrer in der Schule sagte immer und schlug mir ins Gehirn, dass es nur einen Eingang und einen Ausgang für Schleifen geben sollte. Wenn nicht, erhalten Sie Spaghetti-Code und wissen nicht, wohin der Code während des Debuggens geht.

Im wirklichen Leben denke ich, dass die Lesbarkeit von Code wirklich wichtig ist, damit jemand anderes ein Problem mit Ihrem Code beheben oder debuggen muss, was für ihn einfach ist.

Wenn es sich um ein Leistungsproblem handelt, weil Sie diesen Look millionenfach durchlaufen, ist die for-Schleife möglicherweise schneller. Testen würde diese Frage beantworten.

Ich kenne C ++ nicht, aber ich habe die ersten beiden Ihrer Codebeispiele vollständig verstanden. Ich gehe davon aus, dass continue bis zum Ende der for-Schleife geht und diese dann erneut wiederholt. Das while-Beispiel habe ich vollständig verstanden, aber für mich war es einfacher zu verstehen als Ihr for (;;) - Beispiel. Beim dritten musste ich einige Gedanken machen, um es herauszufinden.

Also ging für mich vorbei, was einfacher zu lesen war (ohne C ++ zu kennen) und was mein Logiklehrer sagte, ich würde die while-Schleife eins verwenden.

Für mich ist die einfachste C-Übersetzung des Pseudocodes

do
    {
    success = something();
    if (success == FALSE)
        {
        handle_the_error();
        }
    } while (success == FALSE)
\\ moving on ...

Ich verstehe nicht, warum diese offensichtliche Übersetzung ein Problem ist.

vielleicht das:

while (!something())
    {
    handle_the_error();
    }

das sieht einfacher aus.