Why are empty statements legal?

Question

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

In both C and C++, this is allowed because an expression-statement may be just a ;, which makes it a "null statement". Why is this allowed?

Answer 1

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

Answer 2

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

Answer 3

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

Answer 4

OK, I’ll add this to the worst case scenario that you may actually use:

for (int yy = 0; yy < nHeight; ++yy) {
    for (int xx = 0; xx < nWidth; ++xx) {
        for (int vv = yy - 3; vv <= yy + 3; ++vv) {
            for (int uu = xx - 3; uu <= xx + 3; ++uu) {
                if (test(uu, vv)) {
                    goto Next;
                }
            }
        }
    Next:;
    }
}   

Answer 5

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

Obviously, it is so that we can say things like

for (;;) {
  // stuff
}

Who could live without that?

Answer 8

There are already many good answers but have not seen the productive-environment sample.

Here is FreeBSD's implementation of strlen:

size_t
strlen(const char *str)
{
    const char *s;

    for (s = str; *s; ++s)
        ;
    return (s - str);
}

Answer 9

When using ;, please also be aware about one thing. This is ok:

a ? b() : c();

However this won't compile:

a ? b() : ; ;

Answer 10

The most common case is probably

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

Answer 11

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