Es “} while (0);” siempre igual a “break;} while (1);”?

Question

He comparado gcc salida de ensamblador

do{ 

//some code 

}while(0);

con

do{

//some code

 break; 
}while(1);

La salida es igual, con o sin optimización, pero ..

Es siempre así?

Ningún experimento puede probar teorías, que sólo puede mostrar que están equivocados

Answer 1

Hay una ligera diferencia:

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

reiniciará el bucle cuando condition es cierto, mientras que en la versión } while(0);, la continue será equivalente a break.

Si no hay continue está presente, entonces se debe producir exactamente el mismo código.

Answer 2

Las formas no son equivalentes. Este es un bucle infinito:

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

Esto no es:

do {
    continue;
} while (0);

Answer 3

Editar Al leer varios comentarios sobre el asunto, tengo que admitir que esta respuesta es incorrecta. Lo sentimos.

En lugar de:

do{ 

//some code 

}while(0);

o

do{

//some code

 break; 
}while(1);

Me acaba de usar:

//some code

No estoy 100% seguro de si se puede hacer esto en C ++, pero si desea limitar el alcance de las variables, y es por eso que está haciendo esto, sólo tiene que utilizar llaves por sí mismos:

{

 // Some Code

}

Answer 4

Comentario Markus' me señaló a esta respuesta: la diferencia es cuando se utiliza la palabra clave continue

.

En este 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;
}

se obtiene único iteración, mientras que en este 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;
}

se obtiene 30 iteraciones. Probado bajo VS2008.

Answer 5

El hacer mientras cláusulas son lógicamente equivalentes. Si se traducen en el mismo código de bytes depende del compilador a mano. Supongo que la mayoría de los compiladores modernos se dispensarán un trato igual.

Answer 6

EDITAR basa en su comentario de que está utilizando un rato con breaks con el fin de ser capaz de romper el 'bucle' cuando se cumplan ciertas condiciones.

Si esto es lo que estamos tratando de lograr:

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

... entonces simplemente romper el código que tiene en su bucle while a cabo a una función independiente con múltiples retornos:

void processing()
{

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

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