À quoi sert un bloc 'if (0)' dans un bloc if-else?

Ma question porte sur la ligne que j'ai mentionnée dans le sujet et que je peux voir à de nombreux endroits dans le code de production.

Le code global ressemble à ceci:

if (0) {
    // Empty braces
} else if (some_fn_call()) {
    // actual code
} else if (some_other_fn_call()) {
    // another actual code
    ...
} else {
    // default case
}

Les autres branches ne sont pas pertinentes pour ma question. Je me demande quel est le sens de mettre if (0)ici. Les accolades sont vides, donc je ne pense pas qu'il soit censé commenter un bloc de code. Est-ce que cela force le compilateur à faire une optimisation ou ses intentions sont-elles différentes?

J'ai essayé de rechercher ce cas explicite ici sur SO et sur Internet, mais sans succès. Il y a des questions similaires sur JavaScript, mais pas C. Il y a une autre question, que se passe-t-il quand un zéro est attribué dans une condition `if`? , mais il traite de l'affectation de zéro à une variable, pas de l'utilisation de «if (0)» elle-même.

J'utilise parfois ceci pour la symétrie afin que je puisse déplacer l'autre else if{ librement avec mon éditeur sans avoir à me soucier du premierif .

Sémantiquement le

if (0) {
    // Empty braces
} else 

part ne fait rien et vous pouvez compter sur les optimiseurs pour le supprimer.

Cela peut être utile s'il y a des #ifdéclarations, ala

   if (0)
   {
       // Empty block
   }
#if TEST1_ENABLED
   else if (test1())
   {
      action1();
   }
#endif
#if TEST2_ENABLED
   else if (test2())
   {
      action2();
   }
#endif

etc.

Dans ce cas, tous les tests (et tous) peuvent être #ifsupprimés et le code se compilera correctement. Presque tous les compilateurs supprimeront la if (0) {}pièce. Un simple générateur automatique pourrait générer un code comme celui-ci, car il est légèrement plus facile à coder - il n'a pas à considérer le premier bloc activé séparément.

J'ai vu un modèle similaire utilisé dans le code généré. Par exemple, en SQL, j'ai vu des bibliothèques émettre la whereclause suivante .

where 1 = 1

Cela rend vraisemblablement plus facile d'ajouter simplement d'autres critères, car tous les critères supplémentaires peuvent être ajoutés au début au andlieu d'une vérification supplémentaire pour voir s'il s'agit du premier critère ou non.

Telle qu'elle est écrite, la if (0) {}clause ne se compile à rien.

Je soupçonne que la fonction de la clause en haut de cette échelle est de fournir un endroit facile pour désactiver temporairement toutes les autres fonctionnalités à la fois (à des fins de débogage ou de comparaison) en remplaçant le 0par un 1ou true.

Je ne suis pas sûr des optimisations, mais mes deux cents:

Cela s'est produit à cause d'une modification du code, où une condition principale a été supprimée (l'appel de fonction dans le ifbloc initial , disons), mais les développeurs / mainteneurs

• étaient paresseux pour restructurer le if-elsebloc
• ne voulait pas diminuer le nombre de couverture des succursales

donc au lieu de supprimer le ifbloc associé , ils ont simplement changé la condition if(0)et sont passés à autre chose.

C'est la pourriture du code.

À un moment donné, «si» faisait quelque chose d'utile, la situation a changé, peut-être que la variable évaluée a été supprimée.

La personne qui réparait / changeait le système a fait le moins possible pour affecter la logique du système donc il s'est simplement assuré que le code serait recompilé. Alors il laisse un "si (0)" parce que c'est rapide et facile et il n'est pas totalement sûr que ce soit ce qu'il veut faire. Il fait fonctionner le système et il ne revient pas en arrière pour le réparer complètement.

Ensuite, le développeur suivant arrive et pense que cela a été fait délibérément et ne commente que cette partie du code (car elle n'est de toute façon pas évaluée), puis la prochaine fois que le code est touché, ces commentaires sont supprimés.

Une possibilité non encore mentionnée: la if (0) {ligne pourrait fournir un emplacement pratique pour un point d'arrêt.

Le débogage est souvent effectué sur du code non optimisé, de sorte que le test toujours faux sera présent et pourra avoir un point d'arrêt défini. Une fois compilée pour la production, la ligne de code serait optimisée. La ligne apparemment inutile donne des fonctionnalités pour le développement et le test des versions sans impact sur les versions de version.

Il y a aussi d'autres bonnes suggestions ci-dessus; la seule façon de vraiment savoir quel est le but est de retrouver l'auteur et de demander. Votre système de contrôle de code source pourrait vous aider. (Recherchez la blamefonctionnalité -type.)

J'ai vu des blocs de code non accessibles dans JavaScript pré-développé qui ont été générés à l'aide d'un langage de modélisation.

Par exemple, le code que vous lisez pourrait avoir été collé à partir d'un serveur qui a pré-évalué la première condition qui, à ce moment-là, reposait sur une variable disponible uniquement côté serveur.

if ( ${requestIsNotHttps} ){ ... }else if( ...

qui une fois pré-compilé hences:

if ( 0 ){ ... }else if ( ...

J'espère que cela vous aidera à relativiser la faible activité potentielle du clavier de l'ère des codeurs pro-recyclage pour laquelle je manifeste de l'enthousiasme!

Cette construction peut également être utilisée en C pour implémenter la programmation générique avec la sécurité de type, en s'appuyant sur le fait que le code inaccessible est toujours vérifié par le compilateur:

// this is a generic unsafe function, that will call fun(arg) at a later time
void defer(void *fun, void *arg);

// this is a macro that makes it safer, by checking the argument
// matches the function signature
#define DEFER(f, arg) \
   if(0) f(arg); \              // never actually called, but compile-time checked
   else defer(f, (void *)arg);  // do the unsafe call after safety check

void myfunction(int *p);

DEFER(myfunction, 42);     // compile error
int *b;
DEFER(myfunction, b);      // compiles OK

Je pense que c'est juste un mauvais code. En écrivant un exemple rapide dans Compiler Explorer, nous voyons que dans gcc et clang aucun code n'est généré pour le if (0)bloc, même avec les optimisations complètement désactivées:

https://godbolt.org/z/PETIks

Jouer avec la suppression des if (0)causes ne modifie pas le code généré, je conclus donc que ce n'est pas une optimisation.

Il est possible qu'il y ait eu quelque chose dans le ifbloc supérieur qui a ensuite été supprimé. En bref, il semble que sa suppression entraînerait la génération du même code, alors n'hésitez pas à le faire.

Comme cela a été dit, le zéro est évalué à faux et la branche sera probablement optimisée par le compilateur.

J'ai également vu cela auparavant dans le code où une nouvelle fonctionnalité a été ajoutée et un kill-switch était nécessaire (si quelque chose ne va pas avec la fonctionnalité, vous pouvez simplement la désactiver), et quelque temps plus tard, lorsque le kill-switch a été supprimé le le programmeur n'a pas également supprimé la branche, par exemple

if (feature_a_active()) {
    use_feature_a();
} else if (some_fn()) {
   ...

est devenu

if (0) {
   // empty
} else if (some_fn()) {
   ...

Cela aide à déboguer ce bloc en mettant simplement le bloc if 1. Cela désactive la fonctionnalité de blocage de tous les if else. Et nous pouvons également étendre le bloc if else.

    Actually according to my opinion, if we put any variable for checking inside
    e.g:-
public static void main(string args[])
{
        var status;
        var empList=_unitofWork.EmpRepository.Get(con=>con.isRetired==true);
        //some code logic 
        if(empList.count>0)
        {
          status=true;
        }
        if(status)
        {
         //do something
        }
        else
        {
        //do something else
        }
}
     if then its dynamically get the value in run time and invoke the logic inside it, else its simply extra line of code i guess.

    Anybody have any depth knowledge why this thing is used....or agree with me.
    kindly respond. 

La réponse de @ PSkocik est très bien, mais j'ajoute mes deux cents. Je ne sais pas si je devrais le faire en commentaire ou en réponse; choisir ce dernier, car IMHO vaut la peine d'être vu, alors que les commentaires sont souvent invisibles.

Non seulement j'utilise occasionnellement

if(0) {
   //deliberately left empty
} else if( cond1 ) {
   //deliberately left empty
} else if( cond2 ) {
   //deliberately left empty
...
} else {
   // no conditions matched
}

Mais je fais aussi parfois

if( 1 
    && cond1 
    && cond2
    ...
    && condN
) {

ou

if( 0 
    || cond1 
    || cond2
    ...
    || condN
) {

pour des conditions compliquées. Pour les mêmes raisons - plus facile à modifier, #ifdef, etc.

D'ailleurs, en Perl, je ferai

@array = (  
    elem1,
    elem2,
    ...
    elem1,
) {

• notez la virgule à la fin de la liste. J'oublie si les virgules sont des séparateurs ou des délimiteurs dans les listes C et C ++. À mon humble avis, c'est une chose que nous avons apprise: [ Les virgules en Perl sont-elles une mauvaise pratique? virgules] sont une bonne chose. Comme toute nouvelle notation, il faut un certain temps pour s'y habituer.

Je compare le if(0)code à lisp

(cond   (test1    action1)
   (test2    action2)
   ...
   (testn   actionn))

qui, vous l'avez deviné, je peux indenter comme

(cond   
   (test1    action1)
   (test2    action2)
   ...
   (testn   actionn)
)

J'ai parfois essayé d'imaginer à quoi pourrait ressembler une syntaxe plus lisible par l'homme.

Peut-être

IF
:: cond1 THEN code1
:: cond2 THEN code2
...
:: condN THEN codeN
FI

inspiré du [ https://en.wikipedia.org/wiki/Guarded_Command_Language#Selection:_if[Guarded Command Language] de Dikstra ).

Mais cette syntaxe implique que les conditions sont évaluées en parallèle, alors qu'elle if...else-ifimplique une évaluation séquentielle et hiérarchisée des conditions.

J'ai commencé à faire ce genre de choses en écrivant des programmes qui généraient d'autres programmes, là où c'est particulièrement pratique.

Pendant que nous y sommes, lors de l'écriture de RTL en utilisant l'ancien iHDL d'Intel, j'ai codé des trucs comme

   IF 0 THEN /*nothing*/
   **FORC i FROM 1 TO 10 DOC** 
   ELSE IF signal%i% THEN    
      // stuff to do if signal%i% is active
   **ENDC** 
   ELSE   
      // nothing matched 
   ENDIF

où FORC..DOC..ENDCest une construction de boucle de préprocesseur de macro, qui se développe en

   IF 0 THEN /*nothing*/
   ELSE IF signal1 THEN    
      // stuff to do if signal1 is active
   ELSE IF signal2 THEN    
      // stuff to do if signal2 is active
   ...
   ELSE IF signal100 THEN    
      // stuff to do if signal100 is active
   ELSE   
      // nothing matched 
   ENDIF

Il s'agissait d'un code à affectation unique, non impératif, donc la définition d'une variable d'état n'était pas autorisée si vous deviez faire des choses comme trouver le premier bit défini.

   IF 0 THEN /*nothing*/
   ELSE IF signal1 THEN    
      found := 1
   ELSE IF signal2 THEN    
      found := 2
   ...
   ELSE IF signal100 THEN    
      found := 100
   ELSE   
      // nothing matched 
   ENDIF

À bien y penser, c'est peut-être le premier endroit où j'ai rencontré de telles constructions.

BTW, les objections que certains avaient au style if (0) - que les conditions else-if sont séquentiellement dépendantes et ne peuvent pas être arbitrairement réordonnées - ne s'appliquent pas aux logiques AND et OR et XOR dans RTL - mais s'appliquent à short- circuit && et ||.

J'ai vu cela utilisé pour gérer les erreurs, par exemple

if(0){
lable1:
   //do something
}
if(0){
lable2:
   //do something
}
.
.
and so on.

if(condition_fails)
   goto lable1;

Cela peut être utile lorsque goto est utilisé pour gérer les erreurs, les instructions ne sont exécutées que lorsqu'une erreur se produit. J'ai vu cela dans un très vieux code C (où les arguments de fonction sont écrits en dehors du '()'), ne pensez pas que quiconque le suive maintenant.

J'ai vu cela plusieurs fois, je pense que la raison la plus probable est qu'il évaluait quelque chose dans une version / branche ancienne / différente du code, ou peut-être pour le débogage, et le changer en if(0)est un moyen un peu paresseux de supprimer tout ce qui était là .