C: Vergleich mit NULL

Religiöse Argumente beiseite:

  • Option1:

    if (pointer[i] == NULL) ...

  • Option2:

    if (!pointer[i]) ...

In C option1 funktionell äquivalent zu option2?

Tut, die später aufgelöst werden schneller durch die Abwesenheit von ein Vergleich ?

InformationsquelleAutor der Frage Andrew Turner | 2009-08-16

  1. 15

    Ich mag die zweite, andere Leute wie das erste.

    Eigentlich bevorzuge ich eine Dritte Art der ersten:

    if (NULL == ptr) {
   ...
}

    Weil ich dann:

    • nicht in der Lage sein, zu verpassen, und geben Sie einfach ein "="
    • nicht verpassen den "== NULL" und verwechseln es das Gegenteil, wenn die Bedingung ist lang (mehrere Zeilen)

    Funktional sind Sie gleichwertig.

    Selbst wenn ein NULL Zeiger ist nicht "0" (alle null-bits), if (!ptr) vergleicht mit der NULL Zeiger.

    Das folgende ist falsch. Es ist immer noch hier, weil es viele Kommentare, die sich auf ihn:
    Vergleichen Sie nicht einen Zeiger mit dem literal null, jedoch. Es funktioniert fast überall, aber ist undefiniert Verhalten, wenn ich mich Recht erinnere.

    InformationsquelleAutor der Antwort Thomas

  2. 32

    Ich bevorzuge die explizite Stil (erste version). Es macht es offensichtlich, dass es ist ein Zeiger und nicht eine Zahl oder etwas anderes, aber es ist nur eine Frage des Stils.

    Aus performance-Sicht sollte es keinen Unterschied machen.

    InformationsquelleAutor der Antwort Laserallan

  3. 28

    Entspricht. So steht es in der Sprache standard. Und die Menschen haben die damndest religiösen Vorlieben!

    InformationsquelleAutor der Antwort Norman Ramsey

  4. 19

    Ist es oft nützlich, davon ausgehen, dass die compiler-Autoren wenigstens ein minimum an Intelligenz. Dem compiler ist nicht geschrieben von concussed Entenküken. Es ist geschrieben von Menschen, mit Jahre Programmier-Erfahrung, und Jahren studierte compiler-Theorie. Dies bedeutet nicht, dass dein compiler ist perfekt, und weiß immer am besten, aber es hat bedeuten, dass es durchaus in der Lage Umgang mit trivialen automatischen Optimierungen.

    Wenn die beiden Formen äquivalent sind, dann warum würde der compiler nur übersetzen in die andere, um sicherzustellen, beide sind gleich effizient?

    Wenn if (pointer[i] == NULL) war langsamer als if (!pointer[i])nicht am compiler ändern Sie einfach es in die zweite, effizientere form?

    Also kein, vorausgesetzt, Sie sind gleichwertig, Sie sind gleichermaßen effizient.

    Als für den ersten Teil der Frage, ja, Sie sind gleichwertig. Die Sprache, standard ist eigentlich festgelegt, ist dies explizit irgendwo -- ein pointer wird zu true ausgewertet, wenn es nicht NULL ist, und false, wenn es NULL ist, also die zwei, die genau gleich sind.

    InformationsquelleAutor der Antwort jalf

  5. 9

    Fast sicherlich keinen Unterschied in der Leistung. Ich bevorzuge die impliziten Stil des zweiten, aber.

    InformationsquelleAutor der Antwort Barry Kelly

  6. 3

    NULL erklärt werden sollte in einem der standard-header-Dateien als solche:

    #define NULL ((void*)0)

    So oder So, Sie vergleichen gegen null, und der compiler optimieren sollten beide auf die gleiche Weise. Jeder Prozessor hat einige "Optimierung" oder opcode für den Vergleich mit null.

    InformationsquelleAutor der Antwort Mark Rushakoff

  7. 1

    Frühe Optimierung ist schlecht. Mikro-Optimierung ist auch schlecht, es sei denn, Sie versuchen, squeeze jeden letzten bit der Hz von der CPU, es ist kein Punkt, es zu tun. Als Menschen, die bereits gezeigt haben, kann der compiler optimieren, die die meisten von Ihre-code entfernt sowieso.

    Sein bestes, um Ihren code so prägnant und lesbar wie möglich. Wenn dies mehr lesbar

    if (!ptr)

    als diese

    if (NULL==ptr)

    dann verwenden Sie es. Solange jeder, der Lesen dein code stimmt.

    Ich persönlich verwende die vollständig den vorgegebenen Wert (NULL==ptr), so ist es klar, was ich bin für die überprüfung. Könnte sein, mehr zu geben, aber ich kann einfach Lesen. Ich denke, die !ptr wäre leicht zu übersehen ! wenn das Lesen zu schnell.

    InformationsquelleAutor der Antwort shimpossible

  8. 0

    Es hängt wirklich davon ab, den compiler. Ich wäre überrascht, wenn die meisten modernen C-Compiler nicht generiert nahezu identischen code für den spezifischen Szenario, das Sie beschreiben.

    Holen Sie sich Ihr compiler generiert eine assembly, auflisten für jedes dieser Szenarien und Sie können Ihre eigene Frage zu beantworten (für Ihre speziellen compiler :)).

    Und selbst wenn Sie sind andere, den Unterschied in der Leistung wird wahrscheinlich irrelevant sein, in praktischen Anwendungen.

    InformationsquelleAutor der Antwort

  9. 0

    Schalten compiler-Optimierung und Sie sind im Grunde die gleichen

    getestet, die auf gcc 4.3.3

    int main (int argc, char** argv) {
   char c = getchar();
   int x = (c == 'x');
   if(x == NULL)
      putchar('y');
   return 0;
}

    vs

    int main (int argc, char** argv) {
   char c = getchar();
   int x = (c == 'x');
   if(!x)
      putchar('y');
   return 0;
}


gcc -O -o test1 test1.c
gcc -O -o test2 test2.c


diff test1 test2

    produziert keine Ausgabe 🙂

    InformationsquelleAutor der Antwort Charles Ma

  10. -1

    Ich habe eine assembly dump, und fand den Unterschied zwischen den beiden Versionen:


    @@ -11,8 +11,7 @@
    pushl %ecx
    subl $20, %esp
    movzbl -9(%ebp), %eax
    - movsbl %al,%eax
    - testl %eax, %eax
    + testb %al, %al

    Sieht es aus wie letzteres tatsächlich erzeugt einen Befehl, und die erste erzeugt zwei, aber das ist ziemlich unwissenschaftlich.

    Dies ist gcc (ohne Optimierungen:

    test1.c:

    #include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{ 
  char *pointer[5];

if(pointer[0] == NULL) {
  exit(1);
}

exit(0);

}

    test2.c: Ändern pointer[0] == NULL zu !pointer[0]

    gcc -s test1.c gcc -s test2.c, diff -u test1.s test2.s

    InformationsquelleAutor der Antwort ctennis

  11. -1
    #include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{   
  char pointer[5];  
  /* This is insense you are comparing a pointer to a value */   
  if(pointer[0] == NULL) {     
    exit(1);
  } 
  ...
}

=>           ...    
  movzbl    9(%ebp), %eax  # your code compares a 1 byte value to a signed 4 bytes one 
  movsbl    %al,%eax        # Will result in sign extension...
  testl  %eax, %eax      
              ...

    Vorsicht, gcc haben sollte, stieß eine Warnung, wenn das nicht der Fall, kompilieren Sie mit -Wall Flagge auf
    Sollten Sie jedoch immer kompilieren zu optimierten gcc-code.
    BTW, vor Ihren Variablen mit volatile-Schlüsselwort, um zu vermeiden, gcc aus, ihn zu ignorieren...

    Immer erwähnen in Ihrem compiler-build-version 🙂

    InformationsquelleAutor der Antwort ZeroCool

Schreibe einen Kommentar