Que signifie l'expression " ;" à l'intérieur d'un bloc "if" ?

Question

Pourquoi quelqu'un l'utiliserait-il ?

if(a==1){;} 

Il n'y a pas de déclaration, seulement un point-virgule, et il n'y a pas d'erreur. À quoi sert ce point-virgule ?

Answer 1

Il s'agit d'une déclaration vide de sens. Un point-virgule seul n'effectue aucune opération.

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

Sans un else ce code n'est pas d'une grande utilité. Si c'est le cas, c'est une question de style de savoir si la condition doit être inversée et ne contenir qu'un élément non vide if portion.

Dans ce cas, il s'agit d'une condition simple, il est donc préférable de l'inverser, mais si la condition est plus compliquée, il peut être plus clair de l'écrire de cette façon. Par exemple, ceci :

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

Cela pourrait être plus clair que cela :

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

Ou encore ceci :

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

Un meilleur exemple tiré des commentaires (merci Ben) :

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

Versus :

if (!not_found) {
    // do something
}

Le choix de la méthode dépend en grande partie de la nature exacte de la comparaison, du nombre de termes, de l'imbrication des termes et même des noms des variables/fonctions impliquées.

Un autre exemple d'utilisation est celui d'un ensemble de if..else pour vérifier une plage de valeurs et vous voulez 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 if a été oublié, le lecteur pourrait se demander si quelque chose aurait dû se produire à cet endroit et si le développeur l'a oublié. En incluant l'élément vide if Il dit au lecteur "oui, j'ai tenu compte de cette situation et rien ne devrait se produire dans ce cas".

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

Answer 2

Il s'agit de déclaration nulle .

A partir de 6.8.3 Expression et déclarations nulles :

Une instruction null (composée uniquement d'un point-virgule) n'effectue aucune aucune opération.

Dans cet exemple particulier if(a==1){;} , il ne fait rien d'utile (sauf peut-être un peu plus évident) car c'est la même chose que if(a==1){} o if(a==1); .

Answer 3

Il n'y a aucune raison de le faire. C'est une déclaration vide de sens. Il est possible que le développeur ait voulu faire quelque chose si a n'était pas 1 Dans ce cas, le code serait à peu près le suivant (même si l'élément ; peut encore être omis) :

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

Mais dans ce cas, il aurait été facile de l'écrire comme suit if(a != 1) .

---

Notez cependant que s'il s'agit de C++ (les balises ne sont pas encore claires), il est alors possible que l'élément operator== de type a a été surchargé et certains effets secondaires ont pu être observés. Cela signifierait que le code est insensé.

Answer 4

C'est ce qu'on appelle une déclaration nulle. Il s'agit d'une sorte de déclaration d'expression où l'expression est manquée.

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

Par exemple

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

En général, l'instruction null est utilisée uniquement pour montrer que, par exemple, le corps d'une fonction, d'un constructeur de classe ou d'une boucle for est vide. Par exemple

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

    //...
};

Ou

char * copy_string( char *dsn, const char *src )
{
    char *p = dsn;

    while ( ( *dsn++ = *src++ ) ) ;
                                 ^^^
    return p;
}

Ici, l'instruction null est nécessaire pour la boucle while. Vous pouvez également le réécrire comme suit

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

L'instruction null est parfois nécessaire, en particulier dans les rares cas où l'instruction goto est utilisée. Par exemple, en C, les déclarations ne sont pas des énoncés. Si vous voulez passer le contrôle du programme à un point situé 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 à la mention "null" après l'étiquette. Si vous la supprimez, le compilateur C émettra une erreur.

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

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

   Done:;
}

Bien que vous ne deviez pas utiliser l'instruction goto, vous devez connaître ces cas :)

Answer 5

Comme beaucoup l'ont dit, cela ne sert à rien.

Pourquoi est-il là ? Voici une possibilité

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

Ainsi, puisque nous développons sous Linux avec le compilateur GCC, j'ajoute __attribute__((warn_unused_result)) à la déclaration de toutes mes fonctions typées. Voir aussi cette question pour l'équivalent d'un 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 qu'il ne satisfasse pas à la norme moi :-).