Why are multiple semicolons allowed? [duplicate]

Answer 1

Semicolumn is an empty statement, means "do nothing". Typical example when multiply semicolumns are required is an infinite for loop

  for (int i = 0; i < count; ++i) { // <- ordinary for
    ...
  }

  for (;;) { // <- infinite (for) loop with no initialization, check and increment 
    ...
  }

Answer 2

; is only a line terminator, which tells compiler that this statement is over. If you are using multiple ; in one line, the compiler will think they are multiple statements.

Answer 3

That's because the semicolon, when used alone, represents the empty statement.

The documentation says:

The empty statement consists of a single semicolon. It does nothing and can be used in places where a statement is required but no action needs to be performed.

And provides the following example:

void ProcessMessages()
{
    while (ProcessMessage())
        ; // Statement needed here.
}

Of course, you can execute as many empty statements as you want in sequence, and nothing will happen.

Answer 4

Semicolon when used alone represents empty statement.

Also, refer to the answers here - Legal to allow multiple semicolons with nice detailed explanation that why its perfectly legal. Refer to answer by Binary Worrier explained for macros.

From that post -

You can redefine macros to be different to their initial definition, also you can redefine them so they don't exist at all.

Given an assertion macro #define ASSERT(c) if(!c) throw new AssertionFailedException() you can have your coded littered with ASSERT statements.

void Foo(int x) {
    int y = x + 2;
    ASSERT(y != 0);
   int z = x / y;
    . . . .
}

Now consider that you only want the asserts in debug builds, but not in release builds, for release you redefine the macro to be empty (literally #define ASSERT). Now when Foo goes to the compiler for a release build, it looks like this

void Foo(int x) {
    int y = x + 2;
    ;
   int z = x / y;
    . . . .
}

There's now an empty statement where the ASSERT was, because there may or may not be a statement there (depending on build configuration), the compiler needs to be able to handle an empty statement.

Why this convention was kept in C# where there are nothing like C macros, I have no idea, but possibly because it causes little or no harm.

I would guess that multiple ; are elided by the compiler before it starts parsing code, therefore your unreachable ; is ignored by the compiler.

Answer 5

';' stands for empty statement.

int a;;;;;; // this states that one statement and 5 empty statements 

so there is no bug in this.

Answer 6

The empty statement is valid in all C-derived languages. The most common idiomatic use is in a for statement, e.g.:

for (; ; )
{
}

OR

while (Method())
   ;

OR

void F() {
   //...
   if (done) goto exit;
   //...
   exit: ;
}

OR

if (true)
 {
      ;
 }

OR

if (true)
    ;

All statement are valid.