Qual é a vantagem de um do-while (false)?

Question

Ao olhar através de algum código que foi tratado por um outro funcionário, eu vejo um monte de código escrito em:

do{
    ...
}while(false);

Que vantagem (se houver) que este oferece?

Aqui é mais de um esqueleto que está acontecendo no 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:

C ++ Versão:
são do-while-falsa laços comum?

Answer 1

Talvez ele foi feito para ser capaz de saltar para fora do "laço" a qualquer momento, por exemplo:

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

Mas, como já foi dito, eu não iria fazê-lo assim.

Answer 2

Em Java, não há nenhuma razão para fazer isso.

Em C, este é um idioma comum ao definir macros:

Considere o seguinte:

#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

... mas macros em C são maus e devem ser evitados, se possível.

Será que o seu colega de trabalho vêm de um fundo C?

Answer 3

No vantagem. Não fazê-lo.

Answer 4

Ele pode ser usado para ir para o fim de um bloco que pode ser usado para evitar um monte aninhados if / then blocos.

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);

Answer 5

Este é utilizado em C para definir bloco dentro de macro. Consulte este por exemplo.

exemplo, o seguinte é inválido:

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

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

mas com essa definição, ele vai trabalhar:

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

Answer 6

É inútil, mas o codificador poderia ter usado um vários comandos de quebra para fazer alguma manipulação de exceção estranho.

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

Com certeza é estúpido, mas eu encontrar algo parecido em um programa c idade, uma vez

Answer 7

Sua intuição está certa. Isso é uma coisa completamente inútil para fazer.

É possível que quem codificado que originalmente tinha algo diferente de false como a condição, e simplesmente mudou para false em vez de remover o bloco inteiro para não perder esta "história" do código. Esta é uma justa embreagem em palhas no entanto. Para ser franco é apenas um exemplo simples de um tautologia , que não tem lugar no código.

Answer 8

Em praticamente todos os idioma diferente do C / C ++ isso não fornece nenhuma vantagem tática.

Em C / C ++ existe um caso com macros onde fazer / while (false) torna mais fácil para expandir a macro com segurança em várias instruções. Isto é vantajoso quando a macro de outra forma se parece com uma chamada de função normal.

Answer 9

Tenha um olhar neste questão

O OP pergunta sobre esta construção exata e explica algumas das razões para usá-lo. O consenso parece ser que é uma coisa ruim para fazer.

Answer 10

Como um espaço reservado para um futuro quando alguma outra condição é colocado no lugar de false.

Answer 11

Pode ser usado para ignorar a execução de um código (como um goto ou algo assim), mas quando eu olhar para ele de novo, parece haver um loop for (onde as declarações if(...) break; são) na do-while. Caso contrário, eu diria que seria uma versão Java de um goto ...

Answer 12

Eu usei esta convenção por anos! É mais útil quando você tem um "pipeline" de processamento e / ou verificações condicionais. Ele simplesmente evita vários níveis de instruções aninhadas if () e, portanto, torna o código (muito) mais fácil de ler. Sim, existem alternativas como o try / catch e eu só usar este estilo em determinadas situações / de nível inferior fina.

Eu iniciar o "laço" (nunca realmente laços) com um comentário como ...

// Error loop (never loops)

O erro de loop é ...

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

  if (that)
    break;

  // Success
  set errorCode = ok;

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

Considere este estilo se você tem um monte de if aninhadas () declarações e os seus travessões ir mais de 3 níveis de profundidade.

Eu usei essa convenção em Perl, C / C ++, Java e Delphi / Pascal.

Answer 13

Estou indo para adivinhar o autor de que não confiava em seu código para que ele usado para executá-lo algumas vezes para ver se isso fez trabalhar mais e isso é os restos arqueológicos de que.

Answer 14

A única razão que eu posso pensar é criar um bloco para fazer variáveis ??declaradas dentro do {...} com escopo mais restrito, mas há melhores maneiras de fazer isso (como a criação de funções, ou apenas criar blocos - hat dica para Pete Kirkham) .