Perché le espressioni vuote sono legali in C/C++?

Question

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

Answer 1

Questo è il modo in cui C e C++ esprimono NOP.

Answer 2

Non sono un designer di lingue, ma la risposta che darei è "perché no?" Dal punto di vista della progettazione linguistica, si desidera che le regole (ad esempio la grammatica) siano il più semplici possibile.

Senza contare che le espressioni "vuoti" hanno usi, cioè

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

Will dead-wait (non è un buon uso, ma un uso comunque).

MODIFICA: come indicato in un commento a questa risposta, qualsiasi compilatore che meriti il ​​suo contenuto probabilmente non è occupato da attendere questo ciclo e ottimizzarlo. Tuttavia, se ci fosse qualcosa di più utile nella testa stessa (diversa da i ++), che ho visto fare (stranamente) con attraversamento della struttura dei dati, allora immagino che potresti ancora costruire un ciclo con un corpo vuoto (usando/abusando del costrutto "per").

Answer 3

Il caso più comune è probabilmente

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

Answer 4

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

Ci sono momenti in cui si vuole sedersi e non fare nulla. Un'applicazione incorporata basata su eventi/interrupt o quando non si desidera che una funzione esca come quando si impostano i thread e si attende il primo switch di contesto.

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

Answer 5

E 'ovviamente in modo che possiamo dire le cose come

for(;;) { 
    // stuff 
} 

Chi potrebbe vivere senza questo?

Answer 6

Sinceramente non so se questo è il vero motivo, ma penso che qualcosa che abbia più senso sia pensarlo dal punto di vista di un implementatore di compilatori.

Grandi porzioni di compilatori sono creati da strumenti automatici che analizzano classi speciali di grammatiche. Sembra molto naturale che le grammatiche utili consentano dichiarazioni vuote. Sembra un lavoro inutile per rilevare un tale "errore" quando non cambia la semantica del codice. L'istruzione vuota non farà nulla, in quanto il compilatore non genererà il codice per quelle istruzioni.

Mi sembra che questo è solo un risultato di "Non fissare qualcosa che non è rotto" ...

Answer 7

Come altro potrebbe assert(foo == bar); compilare verso il basso per nulla quando NDEBUG è definito?

Answer 8

si vuole essere in grado di fare cose come

while (fnorble(the_smurf) == FAILED) 
    ; 

e non

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

Ma! Si prega di non scrivere la dichiarazione vuota sulla stessa linea, in questo modo:

while (fnorble(the_smurf) == FAILED); 

Questo è un ottimo modo per confondere il lettore, dal momento che è facile perdere il punto e virgola, e quindi pensare che la riga successiva è il corpo del ciclo. Ricorda: la programmazione riguarda davvero la comunicazione, non con il compilatore, ma con altre persone che leggeranno il tuo codice. (! O con te stesso, tre anni più tardi)

Answer 9

OK, aggiungerò questo per lo scenario peggiore che si può effettivamente utilizzare:

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 10

Quando si utilizza ';' per favore anche essere consapevoli di una cosa. Questo è ok:

a ? b() : c(); 

Tuttavia questo non compilerà:

a ? b() : ; ;