do { ... } while(0) in C: The Macro Pattern That Prevents if-else Bugs

A multi-statement macro without a wrapper breaks in if-else chains. The semicolon after the macro invocation creates an empty statement that separates the if from its else. The do { ... } while(0) pattern wraps the statements in a single syntactic unit that consumes the trailing semicolon. The loop executes exactly once. The while(0) condition is always false. It is not a loop. It is a scoping trick. Every multi-statement macro in every serious C codebase uses this pattern.

#The Problem Without the Pattern#link

The macro expanded to two statements. The semicolon after the invocation terminated the if body after the first printf. The second printf became a standalone statement. The else had no matching if. Compile error. This is the bug the do-while(0) pattern prevents.

#The Fix#link

The do-while(0) wraps both printf calls in a single compound statement. The semicolon after the macro invocation terminates the do-while, not the if. The else binds correctly. The loop executes once because while(0) is false. The compiler optimizes away the loop overhead entirely. At -O1 and above, the generated code is identical to two inline printf calls.

#Where You Will See This#link

The Linux kernel uses do-while(0) in hundreds of macros. The GTK library uses it. Every logging macro, every assertion macro, every resource cleanup macro in production C code uses it. If you write a macro with more than one statement and you do not wrap it in do-while(0), you are writing a bug that will manifest the first time someone uses your macro in an if-else without braces.

do-while(0) is the duct tape of C macros. It is not elegant. It is not obvious. It works. It has worked for forty years. Use it in every multi-statement macro. Your future self, debugging an else-without-if error at 2 AM, will be grateful. Next: creating a library and splitting a program across multiple files.