Was ist der Zweck eines 'if (0)' - Blocks im if-else-Block?

Meine Frage bezieht sich auf die Zeile, die ich im Betreff erwähnt habe und die ich an vielen Stellen im Produktionscode sehen kann.

Der Gesamtcode sieht folgendermaßen aus:

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

Die anderen Zweige sind für meine Frage irrelevant. Ich frage mich, was es bedeutet, if (0)hier zu setzen . Die geschweiften Klammern sind leer, daher denke ich nicht, dass sie einen Codeblock kommentieren sollen. Erzwingt es den Compiler, eine Optimierung vorzunehmen, oder unterscheiden sich seine Absichten?

Ich habe versucht, diesen expliziten Fall hier auf SO und im Internet zu suchen, aber ohne Erfolg. Es gibt ähnliche Fragen zu JavaScript, aber nicht zu C. Es gibt eine andere Frage: Was passiert, wenn eine Null in einer Wenn-Bedingung zugewiesen wird? Es wird jedoch die Zuweisung von Null zu einer Variablen erörtert, nicht die Verwendung von 'if (0)' selbst.

Ich benutze dies manchmal aus Symmetriegründen, damit ich den anderen else if{mit meinem Editor frei bewegen kann, ohne auf den ersten achten zu müssen if.

Semantisch die

if (0) {
    // Empty braces
} else 

Teil macht nichts und Sie können sich darauf verlassen, dass Optimierer es löschen.

Dies kann nützlich sein, wenn es #ifAussagen gibt, ala

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

etc.

In diesem Fall können alle (und alle) Tests #ifgelöscht werden, und der Code wird korrekt kompiliert. Fast alle Compiler entfernen das if (0) {}Teil. Ein einfacher Autogenerator könnte Code wie diesen generieren, da er etwas einfacher zu codieren ist - er muss den ersten aktivierten Block nicht separat betrachten.

Ich habe ein ähnliches Muster gesehen, das im generierten Code verwendet wird. In SQL habe ich beispielsweise gesehen, dass Bibliotheken die folgende whereKlausel ausgeben .

where 1 = 1

Dies erleichtert vermutlich das Hinzufügen anderer Kriterien, da allen zusätzlichen Kriterien andanstelle einer zusätzlichen Prüfung vorangestellt werden kann, ob es sich um das erste Kriterium handelt oder nicht.

Wie geschrieben, if (0) {}kompiliert die Klausel zu nichts.

Ich vermute, dass die Funktion der Klausel oben auf dieser Leiter darin besteht, einen einfachen Ort bereitzustellen, an dem alle anderen Funktionen auf einmal vorübergehend deaktiviert werden können (zu Debugging- oder Vergleichszwecken), indem 0in a 1oder geändert wird true.

Ich bin mir keiner Optimierung sicher, aber meine zwei Cent:

Dies geschah aufgrund einer Codeänderung, bei der eine Hauptbedingung entfernt wurde (der Funktionsaufruf im Anfangsblock if, sagen wir), aber die Entwickler / Betreuer

• waren faul , den if-elseBlock umzustrukturieren
• wollte nicht auf die Anzahl der Filialabdeckungen sinken

Anstatt den zugehörigen ifBlock zu entfernen , änderten sie einfach die Bedingung in if(0)und gingen weiter.

Es ist Code Rot.

Irgendwann, als "wenn" etwas Nützliches tat, änderte sich die Situation, möglicherweise wurde die zu bewertende Variable entfernt.

Die Person, die das System reparierte / änderte, tat so wenig wie möglich, um die Logik des Systems zu beeinflussen , und stellte nur sicher, dass der Code neu kompiliert wurde. Also hinterlässt er ein "if (0)", weil das schnell und einfach geht und er nicht ganz sicher ist, ob er das tun möchte. Er bringt das System zum Laufen und geht nicht zurück, um es vollständig zu reparieren.

Dann kommt der nächste Entwickler und denkt, dass dies absichtlich gemacht wurde und kommentiert nur diesen Teil des Codes aus (da er sowieso nicht ausgewertet wird). Wenn der Code das nächste Mal berührt wird, werden diese Kommentare entfernt.

Eine noch nicht erwähnte Möglichkeit: Die if (0) {Linie könnte einen geeigneten Ort für einen Haltepunkt bieten.

Das Debuggen wird häufig für nicht optimierten Code durchgeführt, sodass der immer falsche Test vorhanden ist und ein Haltepunkt festgelegt werden kann. Bei der Kompilierung für die Produktion würde die Codezeile optimiert. Die scheinbar nutzlose Zeile bietet Funktionen zum Entwickeln und Testen von Builds, ohne die Release-Builds zu beeinträchtigen.

Es gibt auch andere gute Vorschläge oben; Der einzige Weg, um wirklich zu wissen, was der Zweck ist, besteht darin, den Autor aufzuspüren und zu fragen. Ihr Quellcode-Kontrollsystem könnte dabei helfen. (Suchen Sie nach blameFunktionen vom Typ.)

Ich habe nicht erreichbare Codeblöcke in vorerweitertem JavaScript gesehen, die mit einer Vorlagensprache generiert wurden.

Beispielsweise könnte der Code, den Sie lesen, von einem Server eingefügt worden sein, der die erste Bedingung vorab ausgewertet hat, die zu diesem Zeitpunkt auf einer Variablen beruhte, die nur auf der Serverseite verfügbar war.

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

die einmal vorkompilierte Hences:

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

Ich hoffe, dies hilft Ihnen dabei, die potenziell niedrige Tastaturaktivität der Pro-Recycling-Codierer-Ära zu relativieren, für die ich Begeisterung zeige!

Dieses Konstrukt kann auch in C verwendet werden, um generische Programmierung mit Typensicherheit zu implementieren, wobei davon ausgegangen wird, dass der nicht erreichbare Code noch vom Compiler überprüft wird:

// 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

Ich denke, es ist nur schlechter Code. Wenn wir ein kurzes Beispiel im Compiler-Explorer schreiben, sehen wir, dass sowohl in gcc als auch in clang kein Code für den if (0)Block generiert wird , selbst wenn die Optimierungen vollständig deaktiviert sind:

https://godbolt.org/z/PETIks

Das Herumspielen mit dem Entfernen der if (0)Ursachen führt zu keinen Änderungen am generierten Code, daher komme ich zu dem Schluss, dass dies keine Optimierung ist.

Es ist möglich, dass sich im oberen ifBlock etwas befand, das später entfernt wurde. Kurz gesagt, es sieht so aus, als würde durch das Entfernen genau derselbe Code generiert. Sie können dies also jederzeit tun.

Wie bereits erwähnt, wird die Null als falsch ausgewertet, und der Zweig wird wahrscheinlich vom Compiler optimiert.

Ich habe dies auch schon einmal in Code gesehen, in dem eine neue Funktion hinzugefügt wurde und ein Kill-Schalter benötigt wurde (wenn etwas mit der Funktion schief geht, können Sie sie einfach ausschalten), und einige Zeit später, als der Kill-Schalter entfernt wurde Der Programmierer hat den Zweig nicht entfernt, z

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

wurden

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

Es ist hilfreich, diesen Block zu debuggen, indem nur if 1 gesetzt wird. Dadurch wird die Blockfunktionalität deaktiviert. Und wir können auch den if else-Block erweitern.

    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. 

@ PSkociks Antwort ist in Ordnung, aber ich addiere meine zwei Cent. Unsicher, ob ich dies als Kommentar oder als Antwort tun soll; Wählen Sie Letzteres, weil IMHO andere sehenswert sind, während Kommentare häufig unsichtbar sind.

Ich benutze nicht nur gelegentlich

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

Aber ich mache es auch gelegentlich

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

oder

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

für komplizierte Bedingungen. Aus den gleichen Gründen - einfacher zu bearbeiten, #ifdef usw.

Im Übrigen werde ich in Perl tun

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

• Beachten Sie das Komma am Ende der Liste. Ich vergesse, ob Kommas Trennzeichen oder Trennzeichen in C- und C ++ - Listen sind. IMHO ist dies eine Sache, die wir gelernt haben: [ Sind nachgestellte Kommas in Perl eine schlechte Praxis? Kommas] sind eine gute Sache. Wie bei jeder neuen Notation dauert es eine Weile, bis man sich daran gewöhnt hat.

Ich vergleiche den if(0)Code mit lisp

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

was, Sie haben es erraten, ich kann einrücken als

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

Ich habe manchmal versucht mir vorzustellen, wie eine besser lesbare Syntax dafür aussehen könnte.

Vielleicht

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

inspiriert von Dikstras [ https://en.wikipedia.org/wiki/Guarded_Command_Language#Selection:_if‹[Guarded Command Language].

Diese Syntax impliziert jedoch, dass die Bedingungen parallel ausgewertet werden, während if...else-ifdie sequentielle und priorisierte Bewertung der Bedingungen impliziert wird.

Ich habe so etwas angefangen, als ich Programme geschrieben habe, die andere Programme generiert haben, wo es besonders praktisch ist.

Während wir gerade dabei sind, RTL mit Intels alter iHDL zu schreiben, habe ich Sachen wie codiert

   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

Dabei FORC..DOC..ENDChandelt es sich um ein Makro-Präprozessor-Schleifenkonstrukt, das auf erweitert wird

   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

Dies war eine nicht zwingende Einzelzuweisung, daher war das Festlegen einer Statusvariablen nicht zulässig, wenn Sie beispielsweise das erste gesetzte Bit suchen mussten.

   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

Wenn ich daran denke, war dies vielleicht der erste Ort, an dem ich auf solche Konstrukte gestoßen bin.

Übrigens gelten die Einwände, die einige gegen den if (0) -Stil hatten - dass die else-if-Bedingungen sequentiell abhängig sind und nicht willkürlich neu angeordnet werden können - nicht für die AND- und OR- und XOR-Logik in RTL - sondern für Short- Schaltung && und ||.

Ich habe gesehen, dass dies zum Beispiel zur Behandlung von Fehlern verwendet wurde

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

if(condition_fails)
   goto lable1;

Dies kann hilfreich sein, wenn goto zum Verwalten von Fehlern verwendet wird. Anweisungen werden nur ausgeführt, wenn ein Fehler auftritt. Ich habe dies in sehr altem C-Code gesehen (wo Funktionsargumente außerhalb von '()' geschrieben sind), glaube nicht, dass jetzt jemand dem folgt.

Ich habe dies einige Male gesehen. Ich denke, der wahrscheinlichste Grund ist, dass etwas in einer älteren / anderen Version / einem anderen Zweig des Codes ausgewertet oder möglicherweise zum Debuggen verwendet wurde. Das Ändern in if(0)ist eine etwas träge Methode, um alles zu entfernen, was vorhanden war .