C: Comparison to NULL

Question

Religious arguments aside:

• Option1:

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

• Option2:

  if (!pointer[i]) ...  
  

In C is option1 functionally equivalent to option2?

Does the later resolve quicker due to absence of a comparison ?

Answer 1

I prefer the explicit style (first version). It makes it obvious that there is a pointer involved and not an integer or something else but it's just a matter of style.

From a performance point of view, it should make no difference.

Answer 2

Equivalent. It says so in the language standard. And people have the damndest religious preferences!

Answer 3

I like the second, other people like the first.

Actually, I prefer a third kind to the first:

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

Because then I:

• won't be able to miss and just type one =
• won't miss the == NULL and mistake it for the opposite if the condition is long (multiple lines)

Functionally they are equivalent.

Even if a NULL pointer is not "0" (all zero bits), if (!ptr) compares with the NULL pointer.

The following is incorrect. It's still here because there are many comments referring to it: Do not compare a pointer with literal zero, however. It will work almost everywhere but is undefined behavior IIRC.

Answer 4

It is often useful to assume that compiler writers have at least a minimum of intelligence. Your compiler is not written by concussed ducklings. It is written by human beings, with years of programming experience, and years spent studying compiler theory. This doesn't mean that your compiler is perfect, and always knows best, but it does mean that it is perfectly capable of handling trivial automatic optimizations.

If the two forms are equivalent, then why wouldn't the compiler just translate one into the other to ensure both are equally efficient?

If if (pointer[i] == NULL) was slower than if (!pointer[i]), wouldn't the compiler just change it into the second, more efficient form?

So no, assuming they are equivalent, they are equally efficient.

As for the first part of the question, yes, they are equivalent. The language standard actually states this explicitly somewhere -- a pointer evaluates to true if it is non-NULL, and false if it is NULL, so the two are exactly identical.

Answer 5

Almost certainly no difference in performance. I prefer the implicit style of the second, though.

Answer 6

NULL should be declared in one of the standard header files as such:

#define NULL ((void*)0)

So either way, you are comparing against zero, and the compiler should optimize both the same way. Every processor has some "optimization" or opcode for comparing with zero.

Answer 7

Early optimization is bad. Micro optimization is also bad, unless you are trying to squeeze every last bit of Hz from your CPU, there is no point it doing it. As people have already shown, the compiler will optimize most of your code away anyways.

Its best to make your code as concise and readable as possible. If this is more readable

if (!ptr)

than this

if (NULL==ptr)

then use it. As long as everyone who will be reading your code agrees.

Personally I use the fully defined value (NULL==ptr) so it is clear what I am checking for. Might be longer to type, but I can easily read it. I'd think the !ptr would be easy to miss ! if reading to quickly.

Answer 8

It really depends on the compiler. I'd be surprised if most modern C compilers didn't generate virtually identical code for the specific scenario you describe.

Get your compiler to generate an assembly listing for each of those scenarios and you can answer your own question (for your particular compiler :)).

And even if they are different, the performance difference will probably be irrelevant in practical applications.

Answer 9

Turn on compiler optimization and they're basically the same

tested this on 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

produced no output :)

Answer 10

I did a assembly dump, and found the difference between the two versions:

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


It looks like the latter actually generates one instruction and the first generates two, but this is pretty unscientific.

This is gcc, no optimizations:

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: Change pointer[0] == NULL to !pointer[0]

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

Answer 11

#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      
              ...

Beware, gcc should have bumped out a warning, if not the case compile with -Wall flag on Though, you should always compile to optimized gcc code. BTW, precede your variable with volatile keyword in order to avoid gcc from ignoring it...

Always mention your compiler build version :)