Why are empty expressions legal in C/C++?

Question

int main()
{
  int var = 0;; // Typo which compiles just fine
}

Answer 1

Because you might need something like this:

while (x++ < 10);

In this statement, the semicolon is considered the while body. It's still a valid statement but it doesn't do anything. This increases the consistency of the language.

Answer 2

I'm no language designer, but the answer I'd give is "why not?" From the language design perspective, one wants the rules (i.e. the grammar) to be as simple as possible.

Not to mention that "empty expressions" have uses, i.e.

for (i = 0; i < INSANE_NUMBER; i++);

Will dead-wait (not a good use, but a use nonetheless).

EDIT: As pointed out in a comment to this answer, any compiler worth its salt would probably not busy wait at this loop, and optimize it away. However, if there were something more useful in the for head itself (other than i++), which I've seen done (strangely) with data structure traversal, then I imagine you could still construct a loop with an empty body (by using/abusing the "for" construct).

Answer 3

The most common case is probably

int i = 0;
for (/* empty*/; i != 10; ++i) {
    if (x[i].bad) break;
}
if (i != 10) {
    /* panic */
}

Answer 4

while(1){
    ; /* do nothing */
}

There are times when you want to sit and do nothing. An event/interrupt driven embedded application or when you don't want a function to exit such as when setting up threads and waiting for the first context switch.

example: http://lxr.linux.no/linux+v2.6.29/arch/m68k/mac/misc.c#L523

Answer 5

It's obviously so we can say things like

for(;;) {
  // stuff
}

Who could live without that?

Answer 6

I honestly don't know if this is the real reason, but I think something that makes more sense is to think about it from the standpoint of a compiler implementer.

Large portions of compilers are built by automated tools that analyze special classes of grammars. It seems very natural that useful grammars would allow for empty statements. It seems like unnecessary work to detect such an "error" when it doesn't change the semantics of your code. The empty statement won't do anything, as the compiler won't generate code for those statements.

It seems to me that this is just a result of "Don't fix something that isn't broken"...

Answer 7

How else could assert(foo == bar); compile down to nothing when NDEBUG is defined?

Answer 8

This is the way C and C++ express NOP.

Answer 9

You want to be able to do things like

while ( fnorble(the_smurf) == FAILED )
    ;

and not

while ( fnorble(the_smurf) == FAILED )
    do_nothing_just_because_you_have_to_write_something_here();

But! Please do not write the empty statement on the same line, like this:

while ( fnorble(the_smurf) == FAILED );

That's a very good way to confuse the reader, since it is easy to miss the semicolon, and therefore think that the next row is the body of the loop. Remember: Programming is really about communication -- not with the compiler, but with other people, who will read your code. (Or with yourself, three years later!)