È “} while (0);” pari sempre a “break;} while (1);”?

Question

gcc uscita assembler

Ho confrontato di

do{ 

//some code 

}while(0);

con

do{

//some code

 break; 
}while(1);

L'uscita è uguale, con o senza l'ottimizzazione, ma ..

E 'sempre così?

Nessun esperimento in grado di dimostrare le teorie, possono mostrare solo hanno torto

Answer 1

C'è una leggera differenza:

do {
  // code
  if ( condition )
    continue;
  // code
  break;
} while(1);

Sarà riavviare il ciclo quando condition è vero, mentre nella versione } while(0);, il continue sarà equivalente a break.

Se non continue è presente, allora dovrebbero produrre esattamente lo stesso codice.

Answer 2

Le forme non sono equivalenti. Questo è un ciclo infinito:

do {
    continue;
    break;
} while (1);

Questo non è:

do {
    continue;
} while (0);

Answer 3

Modifica Dopo aver letto vari commenti sulla questione, devo ammettere che questa risposta è sbagliata. Siamo spiacenti.

Al posto di:

do{ 

//some code 

}while(0);

o

do{

//some code

 break; 
}while(1);

Vorrei solo usare:

//some code

Io non sono sicuro al 100% se si può fare questo in C ++, ma se si vuole limitare l'ambito delle variabili, e questo è il motivo per cui si sta facendo questo, basta usare le parentesi graffe da soli:

{

 // Some Code

}

Answer 4

Commento Markus' mi ha segnalato questa risposta: la differenza è quando si utilizza continue parola chiave

.

In questo caso:

int _tmain(int argc, _TCHAR* argv[])
{
    int i = 0;
    do {
        ++i;
        _tprintf(_T("Iteration %d\n"), i);
        if (i < 30) continue;
    } while(0);

    return 0;
}

si ottiene un solo iterazione, mentre in questo caso:

int _tmain(int argc, _TCHAR* argv[])
{
    int i = 0;
    do {
        ++i;
        _tprintf(_T("Iteration %d\n"), i);
        if (i < 30) continue;
        break;
    } while(1);

    return 0;
}

si ottiene 30 iterazioni. Testato sotto VS2008.

Answer 5

Il fare, mentre le clausole sono logicamente equivalenti. Se essi sono tradotti sullo stesso codice byte dipende dal compilatore a portata di mano. Credo che la maggior parte dei compilatori moderni li tratteranno allo stesso modo.

Answer 6

EDIT basa sul commento che si sta utilizzando un po 'con breaks al fine di essere in grado di spezzare il 'loop', quando sono state soddisfatte determinate condizioni.

Se questo è quello che stai cercando di realizzare:

do
{ 
  // processing step 1
  if( some_condition )
    break;
  // processing step 2
  if( some_condition )
    break;
  // etcetera..
} while(0)

... poi basta rompere il codice che avete nel vostro ciclo, mentre fuori ad una funzione stand-alone con rendimenti più:

void processing()
{

  // processing step 1
  if( some_condition )
    return;
  // processing step 2
  if( some_condition )
    return;
  // etcetera..
}

int main()
{
  // ...
  processing();
  return 0;
}