Semi Colon dopo le parentesi graffe dichiarazione classe

Question

Ci scusiamo in anticipo per quella che è probabilmente una domanda stupida, ma nelle classi C++, perché il punto e virgola dopo la parentesi graffa 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 realmente le cose come

class MyClass 
{ 
. 
. 
. 
} MyInstance; 

Edit: ricevo da un punto di compatibilità C di vista per le strutture e le enumerazioni, ma dal momento che le classi non sono parte del linguaggio C Credo che sia in primo luogo c'è il mastio 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.

Answer 1

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

E sì, la gente fa davvero fare 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 punti e virgola. Per quanto riguarda il motivo per cui è necessario nel caso più generale di dichiarare nel file di intestazione non sono sicuro. Il mio indovina è che è storico ed è stato fatto per semplificare la scrittura del compilatore.

Answer 2

Suppongo che sia perché le classi sono dichiarazioni, anche quando hanno bisogno di parentesi per il raggruppamento. E sì, c'è l'argomento storico che dal momento che in C si potrebbe fare

struct 
{ 
    float x; 
    float y; 
} point; 

si dovrebbe in C++ in grado di fare una cosa simile, ha senso per la dichiarazione class a comportarsi nello stesso modo.

Answer 3

E 'l'abbreviazione di

class MyClass 
{ 
. 
. 
. 
}; 

// instance declaration 
MyClass MyInstance; // semicolon here 

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

Answer 4

Non faccio uso di tali dichiarazioni

class MyClass 
{ 
. 
. 
. 
} MyInstance; 

Ma in questo caso posso capire perché è punto e virgola lì.
Perché è come int a; - dichiarazione variabile.

Probabilmente per la coerenza in quanto è possibile omettere il punto e virgola "MyInstance".

Answer 5

E 'necessario dopo una struct per ragioni di compatibilità, e come è possibile in questo modo:

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

Answer 6

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

Nel tuo esempio

class MyClass{...} MyInstance; 

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

class MyClass{...} MyInstance1, MyInstance2; 

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

int a, b, c; 

Il motivo uno non lo fa spesso si vede una tale desclarazione di classe e istanza, è l'istanza potrebbe? essere una variabile globale e in realtà non desideri oggetti globali a meno che non siano strutture statiche e/o Plain Old Data.

Answer 7

Il link fornito da @MichaelHeran 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; 
} 

più vecchio versioni di C ha avuto un tipo int rendimento implicito da una funzione ove non dichiarato. Se omettiamo lo ; alla fine della definizione della struttura, non definiamo solo un nuovo tipo fred, ma dichiariamo che main() restituirà un'istanza di fred. Cioè il codice sarebbe stato analizzato in questo modo:

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