What is the advantage of a do-while(false)?

Question

When looking through some code that was handled by another employee, I see a lot of code written in:

do{
    ...
}while(false);

What advantage (if any) does this provide?

Here is more of a skeleton that is happening in the code:

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++ Version:
Are do-while-false loops common?

Answer 1

No advantage. Don't do it.

Answer 2

Your intuition is right. That is a completely useless thing to do.

It is possible that whoever coded it originally had something other than false as the condition, and simply changed it to false rather than removing the entire block not to lose this "history" of the code. This is a just clutching at straws however. To be quite frank it's just a plain example of a tautology, which has no place in code.

Answer 3

I'm going to guess the author of that didn't trust his code so he used to run it a couple times to see if that made it work more and this is the archeological remains of that.

Answer 4

The only reason I can think of is to create a block to make variables declared within the {...} more tightly scoped, but there are better ways of doing this (like creating functions, or just creating blocks - hat tip to Pete Kirkham).

Answer 5

In pretty much every language other than C/C++ this provides no tactical advantage.

In C/C++ there is a case with macros where do/while(false) makes it easier to expand a macro safely into multiple statements. This is advantageous when the macro otherwise looks like a normal function call.

Answer 6

Maybe it was done to be able to jump out of the "loop" at any time, e.g:

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

But as others have said, I wouldn't do it like this.

Answer 7

This is used in C to define block inside macro. See this for example.

Example, the following is invalid:

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

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

but with this definition, it will work:

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

Answer 8

Have a look at this question

The OP asks about this exact construct and explains some reasons for using it. The consensus seems to be that it's a bad thing to do.

Answer 9

In Java, there is no reason to do this.

In C, this is a common idiom when defining macros:

Consider:

#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

...but macros in C are evil and should be avoided if at all possible.

Does your coworker come from a C background?

Answer 10

It is useless, but the coder could have used a multiple break commands to do some weird exception handling.

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

Granted its stupid, but I did find something like in a old c program once

Answer 11

As a placeholder for a future when some other condition is put in place of false.

Answer 12

It could be used to skip execution of some code (like a goto or something) but when I look at it again, there seems to be a for loop (where the if(...) break; statements are) in the do-while. Otherwise, I would say that it would be a Java version of a goto...