Semi Colon dopo parentesi di dichiarazione di class

Mi scuso in anticipo per quella che è probabilmente una domanda stupida, ma nelle classi C ++, perché il punto e virgola dopo la parentesi di chiusura? Lo dimentico regolarmente e ricevo errori del compilatore, quindi ho perso tempo. Sembra alquanto superfluo per me, il che è improbabile che sia così. Le persone fanno davvero cose simili

class MyClass { . . . } MyInstance; 

Edit: L’ ho preso da un punto di vista della compatibilità C per le strutture e le enumerazioni, ma dato che le classi non fanno parte del linguaggio C, credo che sia principalmente lì a mantenere la coerenza tra costrutti di dichiarazione simili. Quello che stavo cercando era più legato alla logica del design piuttosto che essere in grado di cambiare nulla, anche se un IDE di completamento del codice potrebbe intercettarlo prima della compilazione.

Il punto e virgola dopo la parentesi di chiusura in una dichiarazione di tipo è richiesto dalla lingua. È stato così fin dalle prime versioni di C.

E sì, la gente fa davvero la dichiarazione che hai appena messo lì. È utile per creare tipi di ambito all’interno dei metodi.

 void Example() { struct { int x; } s1; s1.x = 42; struct ADifferentType { int x; }; } 

In questo caso, penso che sia chiaro il motivo per cui sono necessari i semi-colon. Per quanto riguarda il motivo per cui è necessario nel caso più generale di dichiarare nel file di intestazione non sono sicuro. La mia ipotesi è che sia storico ed è stato fatto per semplificare la scrittura del compilatore.

Il collegamento fornito da @MichaelHaren sembra fornire la causa principale . Il punto e virgola (come altri hanno sottolineato) è ereditato da C. Ma questo non spiega perché C lo abbia usato in primo luogo. La discussione include questo gioiello di un esempio:

 struct fred { int x; long y; }; main() { return 0; } 

Le versioni precedenti di C avevano un tipo di ritorno implicito int da una funzione, a meno che non fosse stato dichiarato diversamente. Se omettiamo il ; alla fine della definizione della struttura, non definiamo solo un nuovo tipo fred , ma dichiariamo anche che main() restituirà un’istanza di fred . Cioè il codice sarebbe analizzato in questo modo:

 struct fred { int x; long y; } main() { return 0; /* invalid return type, expected fred type */ } 

Immagino sia perché le classi sono dichiarazioni, anche quando hanno bisogno di parentesi per il raggruppamento. E sì, c’è l’argomento storico che da quando sei in grado di fare

 struct { float x; float y; } point; 

in C ++ dovresti essere in grado di fare una cosa simile, ha senso che la dichiarazione di class comporti allo stesso modo.

È l’abbreviazione di

 class MyClass { . . . }; // instance declaration MyClass MyInstance; // semicolon here 

Il punto e virgola dopo le parentesi graffe della dichiarazione di class è in realtà eccessivo, ma è come viene definito C ++. Il punto e virgola dopo la dichiarazione delle variabili è sempre necessario e ha senso.

Non uso tali dichiarazioni

 class MyClass { . . . } MyInstance; 

Ma in questo caso posso capire perché c’è il punto e virgola.
Perché è come int a; – dichiarazione variabile.

Probabilmente per coerenza, poiché è ansible omettere il punto e virgola “MyInstance”.

È necessario dopo una struct per motivi di compatibilità e come ti piacerebbe questo:

 struct MyStruct { ... }; class MyClass { ... } //inconsistency 

In C / C ++ il; è un terminatore di istruzioni. Tutte le dichiarazioni sono terminate con; per evitare ambiguità (e per semplificare l’analisi). La grammatica è coerente in questo senso. Anche se una dichiarazione di class (o qualsiasi blocco per quella materia) è composta da più righe e è delimitata da {}, è pur sempre semplicemente un’istruzione (il {} è parte dell’istruzione) quindi deve essere terminato con; (Il; non è un separatore / delimitatore)

Nel tuo esempio

 class MyClass{...} MyInstance; 

è la dichiarazione completa. Si potrebbero definire più istanze della class dichiarata in una singola istruzione

 class MyClass{...} MyInstance1, MyInstance2; 

Questo è completamente coerente con la dichiarazione di più istanze di un tipo primitivo in una singola istruzione:

 int a, b, c; 

La ragione per cui non si vede spesso tale distacco di class e istanza, è solo l’istanza? essere una variabile globale e in realtà non desideri oggetti globali a meno che non siano strutture statiche e / o Plain Old Data.