Come strutturare un ciclo che si ripete fino al successo e gestisce i fallimenti

Vorrei scrivere un'istruzione if leggermente diversa, quindi viene presa quando l'input ha esito positivo.

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

È anche più corto.

Che suggerisce un modo più breve che potrebbe piacere al tuo insegnante:

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

Ciò che devi cercare è evitare loop grezzi .

Sposta la logica complessa in una funzione di aiuto e improvvisamente le cose sono molto più chiare:

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...
    }
}

Non è tanto che for(;;) sia cattivo. Non è chiaro come modelli come:

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

O come dice Sjoerd:

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

Consideriamo il pubblico principale per questa roba come i tuoi colleghi programmatori, inclusa la versione futura di te stesso che non ricorda più perché hai interrotto la pausa alla fine in quel modo, o hai saltato la pausa con il continuare. Questo modello dal tuo esempio:

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

... richiede un paio di secondi di pensiero extra per simulare rispetto ad altri modelli. Non è una regola dura e veloce, ma saltare la frase break con il continuare si sente disordinato, o intelligente senza essere utile, e mettere l'istruzione break alla fine del ciclo, anche se funziona, è insolito. Normalmente sia break che continue vengono utilizzati per prematuramente per evacuare il ciclo o l'iterazione del ciclo, quindi vedere uno di questi alla fine si sente un po 'strano anche se non lo è.

Oltre a questo, roba buona!

Il mio istruttore logico a scuola diceva sempre, e mi batteva nel cervello, che dovevano esserci solo un'entrata e un'uscita ai circuiti. In caso contrario, inizi a ricevere il codice spaghetti e non sapere dove sta andando il codice durante il debug.

Nella vita reale, ritengo che la leggibilità del codice sia davvero importante in modo che se qualcun altro debba risolvere o eseguire il debug di un problema con il tuo codice, è facile per loro.

Inoltre, se si tratta di un problema di prestazioni perché stai attraversando questo aspetto milioni di volte il ciclo for potrebbe essere più veloce. I test risponderebbero a questa domanda.

Non conosco il C ++ ma ho completamente compreso i primi due esempi di codice. Suppongo che continui fino alla fine del ciclo for e lo ritorni di nuovo. L'esempio while l'ho capito completamente ma per me è stato più facile da capire rispetto al tuo per (;;) esempio. Il terzo dovrei fare qualche lavoro di riflessione per capirlo.

Quindi, per me è stato più facile leggere (non conoscendo c ++) e quello che il mio istruttore di logica ha detto che avrei usato il ciclo while.

Per me, la traduzione C più diretta dello pseudocodice è

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

Non capisco perché questa traduzione ovvia sia un problema.

forse questo:

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

sembra più semplice.