do while(false) pattern [duplicate]

Answer 1

It provides local scope to that which is inside the macro.

Answer 2

People use it because otherwise, you can screw up your ifs with compound statements. Imagine

#define hai int x; \
x = 0;

if (condition)
    hai;
else
    func();

Imagine what the preprocessed source looks like.

if (condition)
   int x;
   x = 0;
else
   func();

Oh wait- now our else doesn't work.

Macros like that however are typically unnecessary in C++.

Answer 3

If somebody has code that does this:

if (something)
    LOG("My log message");

That would expand to:

if (something)
    Lock<MutualExclusion> lock (logMutex);
    // A bunch of other code

Which is incorrect (only the first line would be under the if statement).

The macro makes sure that the macro call is inside of a block of code.

Answer 4

It turns a block into a single statement. If you just use a block (i.e. code enclosed in {}) strange things can happen, for example

#define STUFF() \
  { do_something(); do_something_else(); }

if (cond)
    STUFF();
else
    //...

the extra semi-colon breaks the syntax. The do {} while(false) instead is a single statement.

You can find more about this and other macro tricks here.

Answer 5

The reason for this weird practice in #define's is to encapsulate the different assignments within a loop that is executed exactly once, so one may use the macro like a function. For example, with the code you posted, one can write:

if(...)
    LOG(x, y);
else
    // Something else

and it is expanded as

if(...)
    do {...} while(false);
else
    // Something else

This would not work without the do...while(false) surrounding the different assignments, because that would be expanded as

if(...)
    Lock<MutualExclusion> lock (logMutex);

// Other code... Outside the if statement!

Also forcing a semicolon after the macro makes it look like a function and you wont get errors because you added an semicolon like after a normal function.

Answer 6

So you are forced to add semicolon at the end of the macro, when you use it. This is a common idiom and only way to enforce it.