"fare ... while" vs. "while"

Possibili duplicati:
While vs. Do While
Quando dovrei usare do-while invece di while loops?

Sto programmando da un po 'di tempo (2 anni di lavoro + 4,5 anni di laurea + 1 anno di pre-college) e non ho mai usato un ciclo di do-while a meno di essere costretto a farlo nel corso di Introduzione alla programmazione. Ho la sensazione crescente di sbagliare la programmazione se non mi imbatto mai in qualcosa di così fondamentale.

Potrebbe essere che non mi sia imbattuto nelle circostanze corrette?

Quali sono alcuni esempi in cui sarebbe necessario utilizzare un do-while invece di un po '?

(La mia scuola era quasi tutta in C / C ++ e il mio lavoro è in C #, quindi se c'è un altro linguaggio in cui ha assolutamente senso perché i do-mentre funzionano in modo diverso, allora queste domande non si applicano realmente.)

Per chiarire ... Conosco la differenza tra a whilee a do-while. Mentre controlla la condizione di uscita e quindi esegue le attività. do-whileesegue le attività e quindi controlla le condizioni di uscita.

Se vuoi sempre che il ciclo venga eseguito almeno una volta. Non è comune, ma di tanto in tanto lo uso. Un caso in cui potresti volerlo utilizzare è il tentativo di accedere a una risorsa che potrebbe richiedere un nuovo tentativo, ad es

do
{
   try to access resource...
   put up message box with retry option

} while (user says retry);

do-while è meglio se il compilatore non è competente per l'ottimizzazione. do-while ha un solo salto condizionale, al contrario di for e while che hanno un salto condizionale e un salto incondizionato. Per le CPU che sono pipeline e non eseguono la previsione dei rami, questo può fare una grande differenza nelle prestazioni di un loop stretto.

Inoltre, poiché la maggior parte dei compilatori è abbastanza intelligente da eseguire questa ottimizzazione, tutti i loop trovati nel codice decompilato saranno solitamente do-while (se il decompilatore si preoccupa anche di ricostruire i loop da gotos locali all'indietro).

L'ho usato in una funzione TryDeleteDirectory. Era qualcosa del genere

do
{
    try
    {
        DisableReadOnly(directory);
        directory.Delete(true);
    }
    catch (Exception)
    {
        retryDeleteDirectoryCount++;
    }
} while (Directory.Exists(fullPath) && retryDeleteDirectoryCount < 4);

Do while è utile quando vuoi eseguire qualcosa almeno una volta. Per quanto riguarda un buon esempio di utilizzo di fare mentre contro mentre, diciamo che vuoi fare quanto segue: Una calcolatrice.

Puoi avvicinarti a questo utilizzando un ciclo e controllando dopo ogni calcolo se la persona vuole uscire dal programma. Ora puoi probabilmente presumere che una volta aperto il programma la persona voglia farlo almeno una volta, quindi puoi fare quanto segue:

do
{
    //do calculator logic here
    //prompt user for continue here
} while(cont==true);//cont is short for continue

Questa è una sorta di risposta indiretta, ma questa domanda mi ha fatto riflettere sulla logica che c'è dietro e ho pensato che valesse la pena condividerla.

Come tutti gli altri hanno detto, usi un do ... whileciclo quando vuoi eseguire il corpo almeno una volta. Ma in quali circostanze vorresti farlo?

Ebbene, la classe di situazioni più ovvia a cui riesco a pensare sarebbe quando il valore iniziale ("non adescato") della condizione di controllo è lo stesso di quando vuoi uscire . Ciò significa che è necessario eseguire il corpo del ciclo una volta per innescare la condizione su un valore non esistente, quindi eseguire la ripetizione effettiva in base a quella condizione. Dato che i programmatori sono così pigri, qualcuno ha deciso di avvolgerlo in una struttura di controllo.

Quindi, ad esempio, la lettura di caratteri da una porta seriale con un timeout potrebbe assumere la forma (in Python):

response_buffer = []
char_read = port.read(1)

while char_read:
    response_buffer.append(char_read)
    char_read = port.read(1)

# When there's nothing to read after 1s, there is no more data

response = ''.join(response_buffer)

Si noti la duplicazione del codice: char_read = port.read(1) . Se Python avesse un do ... whileciclo, avrei potuto usare:

do:
    char_read = port.read(1)
    response_buffer.append(char_read)
while char_read

Il vantaggio aggiuntivo per i linguaggi che creano un nuovo ambito per i cicli: char_readnon inquina lo spazio dei nomi della funzione. Ma nota anche che c'è un modo migliore per farlo, e cioè usando il Nonevalore di Python :

response_buffer = []
char_read = None

while char_read != '':
    char_read = port.read(1)
    response_buffer.append(char_read)

response = ''.join(response_buffer)

Quindi ecco il punto cruciale: nelle lingue con tipi nullable, la situazione si initial_value == exit_valuepresenta molto meno frequentemente, e questo potrebbe essere il motivo per cui non la incontri. Non sto dicendo che non succede mai, perché ci sono ancora momenti in cui una funzione tornerà Nonea significare una condizione valida. Ma a mio parere frettoloso e sommariamente considerato, ciò accadrebbe molto di più se le lingue che hai usato non permettessero un valore che significa: questa variabile non è stata ancora inizializzata.

Questo non è un ragionamento perfetto: in realtà, ora che i valori nulli sono comuni, formano semplicemente un elemento in più dell'insieme di valori validi che una variabile può assumere. Ma in pratica, i programmatori hanno un modo per distinguere tra una variabile che si trova in uno stato sensibile, che può includere lo stato di uscita dal loop, ed è in uno stato non inizializzato.

Li ho usati un bel po 'quando ero a scuola, ma non così tanto da allora.

In teoria sono utili quando si desidera che il corpo del ciclo venga eseguito una volta prima del controllo della condizione di uscita. Il problema è che per i pochi casi in cui non voglio il controllo prima, in genere voglio il controllo di uscita nel mezzo del corpo del ciclo piuttosto che alla fine. In tal caso, preferisco usare il noto for (;;)con un if (condition) exit;da qualche parte nel corpo.

In effetti, se sono un po 'tremante nella condizione di uscita dal ciclo, a volte trovo utile iniziare a scrivere il ciclo come un for (;;) {}con un'istruzione di uscita dove necessario, e poi quando ho finito posso vedere se può essere " ripulito "spostando le inizializzazioni, le condizioni di uscita e / o il codice di incremento all'interno delle forparentesi.

Una situazione in cui è sempre necessario eseguire un pezzo di codice una volta e, a seconda del suo risultato, forse più volte. Lo stesso può essere prodotto anche con un whileciclo regolare .

rc = get_something();
while (rc == wrong_stuff)
{
    rc = get_something();
}

do
{
    rc = get_something();
}
while (rc == wrong_stuff);

do whileè se vuoi eseguire il blocco di codice almeno una volta. whiled'altra parte non sempre verrà eseguito in base ai criteri specificati.

E 'così semplice:

precondizione vs postcondizione

• while (cond) {...} - precondizione, esegue il codice solo dopo il controllo.
• do {...} while (cond) - postcondition, il codice viene eseguito almeno una volta.

Ora che conosci il segreto .. usali con saggezza :)

Vedo che questa domanda ha ricevuto una risposta adeguata, ma vorrei aggiungere questo scenario di caso d'uso molto specifico. Potresti iniziare a usare do ... mentre più frequentemente.

do
{
   ...
} while (0)

è spesso usato per #defines su più righe. Per esempio:

#define compute_values     \
   area = pi * r * r;      \
   volume = area * h

Funziona bene per:

r = 4;
h = 3;
compute_values;

-ma- c'è un trucco per:

if (shape == circle)  compute_values;

poiché questo si espande a:

if (shape == circle) area = pi *r * r;
volume = area * h;

Se lo avvolgi in un ciclo do ... while (0), si espande correttamente in un singolo blocco:

if (shape == circle)
  do
  {
    area = pi * r * r;
    volume = area * h;
  } while (0);

Le risposte finora riassumono l'uso generale del do-while. Ma l'OP ha chiesto un esempio, quindi eccone uno: ottenere l'input dell'utente. Ma l'input dell'utente potrebbe non essere valido, quindi chiedi un input, convalidalo, procedi se è valido, altrimenti ripeti.

Con do-while, ottieni l'input mentre l'input non è valido. Con un ciclo while regolare, si ottiene l'input una volta, ma se non è valido, lo si ottiene ancora e ancora finché non è valido. Non è difficile vedere che il primo è più corto, più elegante e più semplice da mantenere se il corpo del loop diventa più complesso.

L'ho usato per un lettore che legge più volte la stessa struttura.

using(IDataReader reader = connection.ExecuteReader())
{
    do
    {
        while(reader.Read())
        {
            //Read record
        }
    } while(reader.NextResult());
}

Ho usato un do whilequando leggo un valore sentinella all'inizio di un file, ma a parte questo, non penso sia anormale che questa struttura non sia usata troppo comunemente - le do-whiles sono davvero situazionali.

-- file --
5
Joe
Bob
Jake
Sarah
Sue

-- code --
int MAX;
int count = 0;
do {
MAX = a.readLine();
k[count] = a.readLine();
count++;
} while(count <= MAX)

Ecco la mia teoria sul perché la maggior parte delle persone (me compreso) preferisce che i cicli while () {} eseguano {} while (): un ciclo while () {} può essere facilmente adattato per funzionare come un ciclo do..while () mentre il contrario non è vero. Un ciclo while è in un certo modo "più generale". Anche ai programmatori piacciono i modelli facili da capire. Un ciclo while dice all'inizio qual è la sua invariante e questa è una cosa carina.

Ecco cosa intendo per la cosa "più generale". Prendi questo ciclo do.. while:

do {
 A;
 if (condition) INV=false; 
 B;
} while(INV);

Trasformare questo in un ciclo while è semplice:

INV=true;
while(INV) {
 A;
 if (condition) INV=false; 
 B;
}

Ora, prendiamo un modello while loop:

while(INV) {
     A;
     if (condition) INV=false; 
     B;
}

E trasformare questo in un ciclo do.. while, produce questa mostruosità:

if (INV) {
 do
 {
         A;
         if (condition) INV=false; 
         B;

 } while(INV)
}

Ora abbiamo due controlli alle estremità opposte e se l'invariante cambia devi aggiornarlo su due punti. In un certo senso fai .. mentre è come i cacciaviti specializzati nella cassetta degli attrezzi che non usi mai, perché il cacciavite standard fa tutto ciò di cui hai bisogno.

Sto programmando da circa 12 anni e solo 3 mesi fa ho riscontrato una situazione in cui era davvero conveniente usare do-while poiché era sempre necessaria un'iterazione prima di controllare una condizione. Quindi indovina il tuo grande momento è avanti :).

Non riesco a immaginare come sei andato così a lungo senza usare un do...whileloop.

Ce n'è uno su un altro monitor in questo momento e ci sono più loop di questo tipo in quel programma. Sono tutti della forma:

do
{
    GetProspectiveResult();
}
while (!ProspectIsGood());

È una struttura abbastanza comune in un server / consumatore:

DOWHILE (no shutdown requested)
   determine timeout
   wait for work(timeout)
   IF (there is work)
      REPEAT
          process
      UNTIL(wait for work(0 timeout) indicates no work)
      do what is supposed to be done at end of busy period.
   ENDIF
ENDDO

l' REPEAT UNTIL(cond)essere ado {...} while(!cond)

A volte l'attesa per il lavoro (0) può essere più economica per la CPU (anche l'eliminazione del calcolo del timeout potrebbe essere un miglioramento con tassi di arrivo molto elevati). Inoltre, ce ne sono molti risultati della teoria delle code che rendono il numero servito in un periodo frenetico una statistica importante. (Vedi ad esempio Kleinrock - Vol 1.)

Allo stesso modo:

DOWHILE (no shutdown requested)
   determine timeout
   wait for work(timeout)
   IF (there is work)
      set throttle
      REPEAT
          process
      UNTIL(--throttle<0 **OR** wait for work(0 timeout) indicates no work)
   ENDIF
   check for and do other (perhaps polled) work.
ENDDO

dove check for and do other workpuò essere esorbitante da inserire nel ciclo principale o forse un kernel che non supporta un efficientewaitany(waitcontrol*,n) tipo o forse una situazione in cui una coda prioritaria potrebbe far morire di fame l'altro lavoro e l'acceleratore viene utilizzato come controllo della fame.

Questo tipo di bilanciamento può sembrare un trucco, ma può essere necessario. L'uso cieco dei pool di thread vanificherebbe completamente i vantaggi in termini di prestazioni dell'uso di un thread caretaker con una coda privata per una struttura dati complicata ad alta velocità di aggiornamento poiché l'uso di un pool di thread piuttosto che un thread di controllo richiederebbe un'implementazione thread-safe.

Non voglio davvero entrare in un dibattito sullo pseudo codice (ad esempio, se l'arresto richiesto deve essere testato in UNTIL) o sui thread custodi rispetto ai pool di thread - questo ha solo lo scopo di dare un sapore di un caso d'uso particolare di la struttura del flusso di controllo.

Questa è la mia opinione personale, ma questa domanda richiede una risposta radicata nell'esperienza:

• Sto programmando in C da 38 anni e non uso mai do/ whileloops nel codice normale.

• L'unico utilizzo convincente di questo costrutto è nelle macro in cui può racchiudere più istruzioni in una singola istruzione tramite un file do { multiple statements } while (0)

• Ho visto innumerevoli esempi di do/ whileloop con rilevamento di errori fasulli o chiamate di funzioni ridondanti.

• La mia spiegazione per questa osservazione è che i programmatori tendono a modellare i problemi in modo errato quando pensano in termini di do/ whileloop. O perdono un'importante condizione finale o perdono il possibile fallimento della condizione iniziale che spostano alla fine.

Per queste ragioni, sono arrivato a credere che dove c'è un do/ whileloop, c'è un bug , e sfido regolarmente i programmatori principianti a mostrarmi un do/ whileloop dove non riesco a individuare un bug nelle vicinanze.

Questo tipo di loop può essere facilmente evitato: utilizzare for (;;) { ... }ae aggiungere i necessari test di terminazione dove sono appropriati. È abbastanza comune che ci sia bisogno di più di uno di questi test.

Ecco un classico esempio:

/* skip the line */
do {
    c = getc(fp);
} while (c != '\n');

Questo fallirà se il file non termina con una nuova riga. Un banale esempio di un tale file è il file vuoto.

Una versione migliore è questa:

int c;  // another classic bug is to define c as char.
while ((c = getc(fp)) != EOF && c != '\n')
    continue;

In alternativa, questa versione nasconde anche la cvariabile:

for (;;) {
    int c = getc(fp);
    if (c == EOF || c == '\n')
        break;
}

Prova a cercare while (c != '\n');in qualsiasi motore di ricerca e troverai bug come questo (recuperato il 24 giugno 2017):

In ftp://ftp.dante.de/tex-archive/biblio/tib/src/streams.c , function getword(stream,p,ignore), ha una do/ whilee sicuramente almeno 2 bug:

• cè definito come chare
• c'è un potenziale loop infinito while (c!='\n') c=getc(stream);

Conclusione: evita do/ whileloop e cerca bug quando ne vedi uno.

while i loop controllano la condizione prima del loop, do...while loop controllano la condizione dopo il loop. Ciò è utile se si desidera basare la condizione sugli effetti collaterali del ciclo in esecuzione o, come hanno detto altri poster, se si desidera che il ciclo venga eseguito almeno una volta.

Capisco da dove vieni, ma il file do-while è qualcosa che uso raramente e non ho mai usato me stesso. Non stai sbagliando.

Non stai sbagliando. È come dire che qualcuno lo sta facendo male perché non ha mai usato il byteprimitivo. Semplicemente non è così comunemente usato.

Lo scenario più comune in cui mi imbatto in cui utilizzo un ciclo do/ whileè in un piccolo programma di console che viene eseguito in base a un input e si ripeterà tutte le volte che l'utente desidera. Ovviamente non ha senso che un programma per console non venga eseguito in nessun momento; ma oltre la prima volta dipende dall'utente - quindi do/ whileinvece di solo while.

Ciò consente all'utente di provare una serie di input diversi, se lo desidera.

do
{
   int input = GetInt("Enter any integer");
   // Do something with input.
}
while (GetBool("Go again?"));

Sospetto che gli sviluppatori di software usino do/ whilesempre meno in questi giorni, ora che praticamente ogni programma sotto il sole ha una GUI di qualche tipo. Ha più senso con le app della console, poiché è necessario aggiornare continuamente l'output per fornire istruzioni o richiedere all'utente nuove informazioni. Con una GUI, al contrario, il testo che fornisce tali informazioni all'utente può essere semplicemente posizionato su un modulo e non deve mai essere ripetuto a livello di programmazione.

Uso continuamente i cicli do-while durante la lettura dei file. Lavoro con molti file di testo che includono commenti nell'intestazione:

# some comments
# some more comments
column1 column2
  1.234   5.678
  9.012   3.456
    ...     ...

userò un ciclo do-while per leggere fino alla riga "colonna1 colonna2" in modo da poter cercare la colonna di interesse. Ecco lo pseudocodice:

do {
    line = read_line();
} while ( line[0] == '#');
/* parse line */

Quindi farò un ciclo while per leggere il resto del file.

Essendo un programmatore bislacco, molti dei miei progetti di programmazione scolastica utilizzavano interazioni guidate da menu di testo. Praticamente tutti usavano qualcosa di simile alla seguente logica per la procedura principale:

do
    display options
    get choice
    perform action appropriate to choice
while choice is something other than exit

Sin dai tempi della scuola, ho scoperto di utilizzare il ciclo while più frequentemente.

Una delle applicazioni che ho visto è in Oracle quando guardiamo i set di risultati.

Una volta che hai un set di risultati, per prima cosa recuperi da esso (do) e da quel punto in poi .. controlla se il fetch restituisce un elemento o meno (mentre l'elemento trovato ..) .. Lo stesso potrebbe essere applicabile a qualsiasi altro " implementazioni "fetch-like".

L'ho usato in una funzione che restituiva la posizione del carattere successivo in una stringa utf-8:

char *next_utf8_character(const char *txt)
{
    if (!txt || *txt == '\0')
        return txt;

    do {
        txt++;
    } while (((signed char) *txt) < 0 && (((unsigned char) *txt) & 0xc0) == 0xc0)

    return (char *)txt;
}

Nota che questa funzione è scritta dalla mente e non testata. Il punto è che devi comunque fare il primo passo e devi farlo prima di poter valutare la condizione.

Qualsiasi tipo di input della console funziona bene con do-while perché viene richiesto la prima volta e viene nuovamente richiesto ogni volta che la convalida dell'input non riesce.

Anche se ci sono molte risposte qui è la mia opinione. Tutto si riduce all'ottimizzazione. Mostrerò due esempi in cui uno è più veloce dell'altro.

Caso 1: while

string fileName = string.Empty, fullPath = string.Empty;

while (string.IsNullOrEmpty(fileName) || File.Exists(fullPath))
{
    fileName = Guid.NewGuid().ToString() + fileExtension;
    fullPath = Path.Combine(uploadDirectory, fileName);
}

Caso 2: do while

string fileName = string.Empty, fullPath = string.Empty;

do
{
    fileName = Guid.NewGuid().ToString() + fileExtension;
    fullPath = Path.Combine(uploadDirectory, fileName);
}
while (File.Exists(fullPath));

Quindi due faranno esattamente le stesse cose. Ma c'è una differenza fondamentale ed è che il while richiede un'istruzione in più per inserire il tempo. Il che è brutto perché diciamo che ogni possibile scenario della Guidclasse è già stato preso tranne una variante. Ciò significa che dovrò fare un giro di 5,316,911,983,139,663,491,615,228,241,121,400,000volte. Ogni volta che arrivo alla fine della mia dichiarazione while dovrò fare il string.IsNullOrEmpty(fileName)controllo. Quindi questo richiederebbe un po ', una piccola frazione del lavoro della CPU. Ma fai questo compito molto piccolo moltiplicando le possibili combinazioni di fileGuid classe e parliamo di ore, giorni, mesi o tempo supplementare?

Ovviamente questo è un esempio estremo perché probabilmente non lo vedresti in produzione. Ma se pensassimo all'algoritmo di YouTube, è molto probabile che incontrino la generazione di un ID in cui sono già stati presi alcuni ID. Quindi si tratta di grandi progetti e ottimizzazione.

Mi piace intendere questi due come:
while-> 'ripeti fino a',
do ... while-> 'ripeti se'.

Mi sono imbattuto in questo mentre cercavo il ciclo corretto da utilizzare per una situazione che ho. Credo che questo soddisferà pienamente una situazione comune in cui un ciclo do .. while è un'implementazione migliore di un ciclo while (linguaggio C #, poiché hai affermato che è il tuo principale per il lavoro).

Sto generando un elenco di stringhe in base ai risultati di una query SQL. L'oggetto restituito dalla mia query è un SQLDataReader. Questo oggetto ha una funzione chiamata Read () che fa avanzare l'oggetto alla riga di dati successiva e restituisce true se c'era un'altra riga. Restituirà false se non c'è un'altra riga.

Usando queste informazioni, voglio riportare ogni riga in un elenco, quindi fermarmi quando non ci sono più dati da restituire. Un ciclo Do ... While funziona meglio in questa situazione in quanto garantisce che l'aggiunta di un elemento all'elenco avvenga PRIMA di controllare se c'è un'altra riga. Il motivo per cui questo deve essere fatto PRIMA di controllare il while (condizione) è che quando controlla, avanza anche. L'uso di un ciclo while in questa situazione provocherebbe il bypass della prima riga a causa della natura di quella particolare funzione.

In breve:

Questo non funzionerà nella mia situazione.

    //This will skip the first row because Read() returns true after advancing.
    while (_read.NextResult())
           {
               list.Add(_read.GetValue(0).ToString());
           }

   return list;

Questo sarà.

    //This will make sure the currently read row is added before advancing.
    do
        {
            list.Add(_read.GetValue(0).ToString());
        } 
        while (_read.NextResult());

    return list;

Console.WriteLine("hoeveel keer moet je de zin schrijven?");
        int aantal = Convert.ToInt32(Console.ReadLine());
        int counter = 0;

        while ( counter <= aantal)
        {
            Console.WriteLine("Ik mag geen stiften gooien");
            counter = counter + 1;