Que signifie simplement «;» dans un bloc «si» signifie?

Pourquoi quelqu’un utiliserait-il cela?

if(a==1){;} 

Il n’y a pas de déclaration, seulement un point-virgule, et cela ne génère pas d’erreur. À quoi sert ce point-virgule?

C’est une déclaration vide. Un seul point-virgule ne permet aucune opération.

Dans ce contexte, cela signifie que si la condition if est vraie, ne faites rien.

Sans une else section, ce code est peu utilisé. Si c’est le cas, alors il faut savoir si la condition doit être inversée et ne doit contenir qu’une partie non vide.

Dans ce cas, il s’agit d’un conditionnel simple, de sorte que, du sharepoint vue du style, il est probablement préférable de l’inverser, mais si la condition est plus compliquée, il est plus facile d’écrire de cette manière. Par exemple, ceci:

 if ((a==1) && (b==2) && (c==3) && (d==4)) { ; } else { // do something useful } 

Pourrait être plus clair que cela:

 if (!((a==1) && (b==2) && (c==3) && (d==4))) { // do something useful } 

Ou ca:

 if ((a!=1) || (b!=2) || (c!=3) || (d!=4)) { // do something useful } 

Un meilleur exemple des commentaires (merci Ben):

 if (not_found) { ; } else { // do something } 

Contre:

 if (!not_found) { // do something } 

La méthode à utiliser dépend en grande partie de ce qui est comparé, du nombre de termes, de l’imbrication des termes et même du nom des variables / fonctions impliquées.

Un autre exemple d’utilisation de cette if..else est lorsque vous avez un ensemble d’instructions if..else pour vérifier une plage de valeurs et que vous souhaitez documenter dans le code que rien ne doit se produire pour une plage particulière:

 if (a < 0) { process_negative(a); } else if (a >=0 && a < 10) { process_under_10(a); } else if (a >=10 && a < 20) { ; // do nothing } else if (a >=20 && a < 30) { process_20s(a); } else if (a >= 30) { process_30s_and_up(a); } 

Si le vide était omis, un lecteur pourrait se demander si quelque chose aurait dû se passer là et le développeur l’a oublié. En incluant le vide if , cela dit au lecteur “oui je l’ai expliqué et rien ne devrait arriver dans ce cas”.

Certaines normes de codage exigent que tous les résultats possibles soient explicitement pris en compte dans le code. Donc, le code qui adhère à une telle norme pourrait ressembler à ceci.

C’est ce qu’on appelle une déclaration null .

De 6.8.3 Expression et instructions nulles :

Une instruction null (constituée d’un point-virgule) n’effectue aucune opération.

Dans cet exemple particulier, if(a==1){;} , il ne fait rien d’utile (sauf peut-être un peu plus évident) car il en va de même if(a==1){} ou if(a==1); .

Aucun but du tout. C’est une déclaration vide. Il est possible que le développeur veuille faire quelque chose si a n’était pas 1 auquel cas le code serait quelque chose comme (même si le ; peut toujours être omis):

 if(a==1) { ; } else { //useful code... } 

Mais dans ce cas, cela aurait facilement pu être écrit comme if(a != 1) .


Notez cependant que s’il s’agit de C ++ (les balises ne sont pas encore claires), il est possible que l’ operator== du type a soit surchargé et que certains effets secondaires aient été observés. Cela voudrait dire que le code est fou si.

C’est ce qu’on appelle une déclaration nulle. C’est une sorte d’instruction d’expression où l’expression est manquée.

Parfois, il est utilisé dans les instructions if-else, comme vous l’avez montré lorsqu’il est facile d’écrire la condition if que sa négation (ou la condition if est plus claire) mais le code doit être exécuté lorsque la condition if est évaluée à false.

Par exemple

 if ( some_condition ) { ; // do nothing } else { // here there is some code } 

Généralement, l’instruction null est utilisée pour exposer uniquement pour montrer que, par exemple, le corps d’une fonction, ou un constructeur de classe ou une boucle for est vide. Par exemple

 struct A { A( int x ) : x( x ) { ; } //... }; 

Ou

 char * copy_ssortingng( char *dsn, const char *src ) { char *p = dsn; while ( ( *dsn++ = *src++ ) ) ; ^^^ return p; } 

Ici, l’instruction null est requirejse pour la boucle while. Vous pouvez aussi le réécrire comme

  while ( ( *dsn++ = *src++ ) ) {} 

Parfois, l’instruction null est requirejse, en particulier dans les rares cas où l’instruction goto est utilisée. Par exemple, les déclarations C ne sont pas des déclarations. Si vous souhaitez passer le contrôle du programme à un point avant une déclaration, vous pouvez placer une étiquette avant la déclaration. Cependant, en C, une étiquette ne peut être placée qu’avant une déclaration. Dans ce cas, vous pouvez placer une instruction null avec une étiquette avant la déclaration. Par exemple

 Repeat:; ^^^ int a[n]; //.... n++; goto Repeat; 

Faites attention à l’instruction null après l’étiquette. Si le supprimer, le compilateur C générera une erreur.

Cette astuce est également utilisée pour passer le contrôle du programme à la fin d’une instruction composée. Par exemple

 { // some code goto Done; //... Done:; } 

Bien que vous ne devriez pas utiliser l’instruction goto mais vous devriez savoir à propos de ces cas. 🙂

Comme beaucoup l’ont dit, cela ne fait rien.

Pourquoi est-ce là? Voici une possibilité…

J’en ai assez des mauvais codeurs de mon équipe qui ne vérifient pas les valeurs de retour des fonctions.

Donc, comme nous développons sous Linux avec le compilateur GCC, j’ajoute __atsortingbute__((warn_unused_result)) à la déclaration de toutes mes fonctions typées. Voir aussi cette question pour un équivalent MS VC.

Si l’utilisateur ne vérifie pas la valeur de retour, le compilateur génère un avertissement.

Les cow-boys, bien sûr, ont joué avec le système et le code if (foo() != SUCCESS) ; ce qui satisfait le compilateur (bien que cela ne me satisfasse pas :-).

Un célibataire est la déclaration null qui ne fait rien. Il est souvent utilisé dans les longues chaînes if / else comme:

 if (a == 1) { // Do nothing. ; } else if (...) { ... } else if (...) { ... } 

Cela pourrait aussi être écrit comme:

 if (a != 1) { if (...) { ... } else if (...) { ... } } 

Ce dernier ajoute un autre niveau d’indentation mais IMO, c’est plus clair. Mais les instructions null peuvent parfois être utiles pour éviter une indentation excessive s’il existe plusieurs twigs sans code.

Notez qu’une instruction composée vide (également appelée bloc ) a le même effet:

 if (a == 1) {} 

Techniquement, vous n’avez besoin que du point-virgule si vous souhaitez utiliser directement une expression :

 if (a == 1) ; else if (...) { ... } else if (...) { ... } 

Donc, l’écriture {;} est redondante et ne sert qu’un but illustratif douteux.

Un autre exemple du standard C où l’instruction null est utilisée pour fournir un corps de boucle vide:

 char *s; /* ... */ while (*s++ != '\0') ; 

Mais ici, je préférerais aussi une déclaration composée vide.

; à lui seul est une déclaration vide . Si a est un type non pointeur initialisé, alors

if(a==1){;}

est toujours un no-op dans C. L’utilisation des accolades ajoute un poids supplémentaire à l’affirmation qu’il n’y a pas de faute de frappe. Peut-être y a-t-il un else élément directement en dessous, qui s’exécuterait si a n’était pas 1.

Il s’agit essentiellement d’une instruction null / empty , qui ne fait rien et qui est comme prévu bénigne (pas d’erreur) dans la nature.

Le projet de norme C N1570 précise que:

  1. les expressions sont facultatives: expression [opt];
  2. Une instruction null (constituée d’un point-virgule) n’effectue aucune opération.

D’autre part, Bjarne cite dans son livre C ++ #9.2 Statement Summary :

Un point-virgule est à lui seul une déclaration, l’instruction vide.

Notez que ces deux codes, if(1) {;} et if(1) {} , n’ont pas de différence dans les instructions gcc générées.

Pourquoi le feriez-vous? Je fais des choses similaires tout le temps lors du débogage pour me donner quelque chose qui, je l’espère, ne sera pas optimisé pour que je puisse y mettre un point.

Normalement si je le fais évident c’est une marque de débogage

 if( (a==1) && (b==2) && (c==3) && (d==4) ){ int debug=1; } 

Sinon, je me retrouve avec des petits bouts de code étranges, coincés partout, qui n’ont absolument aucun sens, même pour moi.

Mais cela ne garantit pas que c’était ce que c’était.

; est une déclaration vide noop

Quel est son but?

Parfois, nous voulons simplement comparer des choses comme dans ce cas l’égalité de a et 1. Avec des types primitifs tels que des nombres entiers, cela définira le registre de conditions, donc si vous avez après cela quelque chose comme si (a> 1) ou si (a <1 ), et a n'est pas changé entre-temps, cela pourrait ne pas être réévalué en fonction de la décision du compilateur.

Ce code

  int f(int a){ if(a == 1){;} if(a > 1){return 3;} if(a < 1){return 5;} return 0; } 

va donner

 .file "c_rcrYxj" .text .p2align 2,,3 .globl f .type f, @function f: .LFB0: .cfi_startproc cmpl $1, 4(%esp) jle .L6 movl $3, %eax ret .p2align 2,,3 .L6: setne %al movzbl %al, %eax leal (%eax,%eax,4), %eax ret .cfi_endproc .LFE0: .size f, .-f .ident "GCC: (Ubuntu 4.8.4-2ubuntu1~14.04.3) 4.8.4" .section .note.GNU-stack,"",@progbits 

La comparaison est faite seulement une fois cmpl $ 1, 4 (% esp) , exactement où if (a == 1) est écrit.

Vous savez probablement déjà que le point-virgule est une déclaration vide. En ce qui concerne la question réelle “à quoi sert ce point-virgule”, la réponse est (à moins que l’auteur de ce code ne veuille égayer le code avec une émoticône étrange), cela ne sert absolument à rien . C’est-à-dire que {;} est complètement équivalent à {} dans n’importe quel contexte (où une instruction est attendue, ce qui, je pense, est le seul endroit où {;} peut être utilisé). La présence du point-virgule change une instruction composée avec 0 instruction constitutive en une instruction composée avec une déclaration de constitution qui est une instruction vide, mais les deux cas sont équivalents en ce qui concerne la sémantique.

J’appendai une opinion personnelle selon laquelle, pour des raisons de lisibilité, le fait de ne pas être accidentellement négligé par un lecteur du code, {;} n’est pas meilleur que {} (si c’était le cas, alors peut-être que {;;;;;;;;} être encore mieux), même si les deux sont considérablement mieux qu’un solitaire ; (et par conséquent, le langage aurait été mieux sans autoriser ; comme instruction vide du tout, car le remplacer par {} est toujours avantageux).