Pourquoi plusieurs points-virgules sont-ils autorisés?

En effet, le point-virgule, utilisé seul, représente l’ instruction vide .

La documentation dit:

L’instruction vide consiste en un seul point-virgule. Il ne fait rien et peut être utilisé dans les endroits où une déclaration est requirejse mais aucune action ne doit être effectuée.

Et fournit l’exemple suivant:

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

Bien sûr, vous pouvez exécuter autant d’instructions vides que vous le souhaitez et rien ne se passera.

Semicolumn est une instruction vide, qui signifie “ne rien faire”. Un exemple typique de multiplication de points-virgules est une boucle infinie pour

  for (int i = 0; i < count; ++i) { // <- ordinary for ... } for (;;) { // <- infinite (for) loop with no initialization, check and increment ... } 

L’instruction vide est valide dans toutes les langues dérivées du langage C. L’utilisation idiomatique la plus courante est dans une déclaration for, par exemple:

 for (; ; ) { } 

OU

 while (Method()) ; 

OU

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

OU

 if (true) { ; } 

OU

 if (true) ; 

Toutes les déclarations sont valables.

Le point-virgule utilisé seul représente une instruction vide .

Reportez-vous également aux réponses ci-dessous – Légal pour autoriser plusieurs points-virgules avec une explication détaillée détaillée qui explique pourquoi c’est parfaitement légal. Reportez-vous à la réponse de Binary Worrier expliquée pour les macros.

De ce post –

Vous pouvez redéfinir les macros afin qu’elles soient différentes de leur définition initiale. Vous pouvez également les redéfinir afin qu’elles n’existent pas du tout.

#define ASSERT(c) if(!c) throw new AssertionFailedException() une macro d’assertion #define ASSERT(c) if(!c) throw new AssertionFailedException() vous pouvez avoir votre code codé avec des instructions ASSERT.

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

Maintenant, considérez que vous ne voulez que les assertions dans les versions de débogage, mais pas dans les versions de publication, car vous redéfinissez la macro pour qu’elle soit vide (literally #define ASSERT) . Maintenant, quand Foo va au compilateur pour une version release, cela ressemble à ceci

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

Il y a maintenant une instruction vide où ASSERT était, car il peut y avoir ou non une instruction (en fonction de la configuration de la construction), le compilateur doit pouvoir gérer une instruction vide.

Pourquoi cette convention a-t-elle été conservée en C # où il n’y a rien de tel que les macros en C, je n’en ai aucune idée, mais peut-être parce que cela ne cause que peu ou pas de dommages.

Je devinerais ce multiple; sont éliminés par le compilateur avant qu’il ne commence à parsingr le code, donc votre inaccessible; est ignoré par le compilateur.

; est seulement un terminateur de ligne, qui indique au compilateur que cette instruction est terminée. Si vous utilisez plusieurs ; dans une ligne, le compilateur va penser qu’il s’agit de plusieurs déclarations.

‘;’ représente une déclaration vide.

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

donc il n’y a pas de bug dans cela.