¿Cuál es la ventaja de un do-while (falso)?

StackOverflow https://stackoverflow.com/questions/1445025

  •  22-07-2019
  •  | 
  •  

Pregunta

Cuando miro un código manejado por otro empleado, veo mucho código escrito en: 

do{
    ...
}while(false);

¿Qué ventaja (si hay alguna) proporciona esto?

Aquí hay más de un esqueleto que está sucediendo en el código: 

try{
    do{
        // Set some variables

        for(...) {
            if(...) break;
            // Do some more stuff
            if(...) break;
            // Do some more stuff
        }
    }while(false);
}catch(Exception e) { 
    // Exception handling 
}

Update:

  

Versión C ++:
   ¿Son comunes los bucles do-while-false?

¿Fue útil?

Solución

Tal vez se hizo para poder saltar del bucle " en cualquier momento, por ejemplo: 

do
{
    ...
    if (somethingIsWrong) break;
    //more code
    ...
}
while(false);

Pero como han dicho otros, no lo haría así.

Otros consejos

En Java, no hay razón para hacer esto.

En C, este es un idioma común al definir macros:

Considere: 

#define macro1 doStuff(); doOtherStuff()
#define macro2 do{ doStuff(); doOtherStuff(); } while( false )

if( something ) macro1; // only the first statement in macro1 is executed conditionally
if( something ) macro2; // does what it looks like it does

... pero las macros en C son malvadas y deben evitarse si es posible.

¿Su compañero de trabajo proviene de un fondo C?

Sin ventaja. No lo hagas.

Se puede usar para ir al final de un bloque que se puede usar para evitar un montón anidado si / luego bloques. 

do {
    if (done()) continue;
    // do a bunch of stuff
    if (done()) continue;
    // do a bunch more stuff
    if (done()) continue;
    // do even more stuff
} while (false);

Esto se usa en C para definir el bloque dentro de la macro. Consulte esto por ejemplo.

Ejemplo, lo siguiente no es válido: 

#define f(x) { g(x); h(x); }

if (x >= 0) f(x); else f(-x);

pero con esta definición, funcionará: 

#define f(x) do { g(x); h(x) } while(false)

Es inútil, pero el codificador podría haber utilizado múltiples comandos de interrupción para hacer un manejo extraño de excepciones. 

do{
if(<something>){...}else{break}
if(<something else>){...}else{break}
...
}while(false)

Por supuesto que es estúpido, pero una vez encontré algo como en un viejo programa c

Tu intuición es correcta. Eso es algo completamente inútil.

Es posible que quien lo codificó originalmente tenía algo distinto de false como condición, y simplemente lo cambió a false en lugar de eliminar todo el bloque para no perder este " historial " del código Sin embargo, esto es solo agarrar pajitas. Para ser franco, es solo un ejemplo claro de una tautología , que no tiene colocar en el código.

En casi todos los idiomas, excepto C / C ++, esto no proporciona ninguna ventaja táctica.

En C / C ++ hay un caso con macros donde do / while (false) hace que sea más fácil expandir una macro de manera segura en múltiples declaraciones. Esto es ventajoso cuando la macro parece una llamada de función normal.

Eche un vistazo a esta pregunta

El OP pregunta sobre esta construcción exacta y explica algunas razones para usarla. El consenso parece ser que es algo malo que hacer.

Como marcador de posición para un futuro cuando se coloca alguna otra condición en lugar de false .

Podría usarse para omitir la ejecución de algún código (como un goto o algo así) pero cuando lo miro de nuevo, parece que hay un bucle for ( donde las if (...) break; declaraciones están) en el do-while . De lo contrario, diría que sería una versión Java de un goto ...

¡He usado esta convención durante años! Es más útil cuando tiene una "tubería". de procesamiento y / o cheques condicionales. Simplemente evita múltiples niveles de sentencias if () anidadas y, por lo tanto, hace que el código (mucho) sea más fácil de leer. Sí, hay alternativas como try / catch y solo uso este estilo en ciertas situaciones de nivel delgado / bajo.

Comienzo el bucle " (nunca se repite) con un comentario como ... 

// Error loop (never loops)

El bucle de error es ... 

set errorCode = fail;
do {
  if (this)
    break;

  if (that)
    break;

  // Success
  set errorCode = ok;

  // Alternative Success
  errorCode = doWhatever();
} while (false);

Considere este estilo si tiene un montón de instrucciones if () anidadas y sus sangrías tienen más de 3 niveles de profundidad.

He usado esta convención en Perl, C / C ++, Java y Delphi / Pascal.

Voy a adivinar que el autor de eso no confió en su código, por lo que solía ejecutarlo un par de veces para ver si eso funcionaba más y estos son los restos arqueológicos de eso.

La única razón por la que se me ocurre es crear un bloque para hacer que las variables declaradas dentro del {...} tengan un alcance más estricto, pero hay mejores formas de hacerlo (como crear funciones, o simplemente creando bloques: sombrero para Pete Kirkham).

Licenciado bajo: CC-BY-SA con atribución
No afiliado a StackOverflow
scroll top