NULL appears to be zero in my GCC test programs, but wikipedia says that NULL
is only required to point to unaddressable memory.
Do any compilers make NULL
non-zero? I'm curious whether if (ptr == NULL)
is better practice than if (!ptr)
.
The null pointer constant is always 0. The NULL macro may be defined by the implementation as a naked 0 , or a cast expression like (void *) 0 , or some other zero-valued integer expression (hence the "implementation defined" language in the standard). The null pointer value may be something other than 0.
It is safe to free a null pointer. The C Standard specifies that free(NULL) has no effect: The free function causes the space pointed to by ptr to be deallocated, that is, made available for further allocation.
In C, NULL is a macro that expands either to 0 or (void*)0 (or something that has a similar effect). In the first case, you can not differentiate between NULL and 0 , because they are literally the same.
The answer to that is rather simple: a NULL means that there is no value, we're looking at a blank/empty cell, and 0 means the value itself is 0.
NULL
is guaranteed to be zero, perhaps casted to (void *)
1.
C99, §6.3.2.3, ¶3
An integer constant expression with the value
0
, or such an expression cast to typevoid *
, is called a null pointer constant.(55) If a null pointer constant is converted to a pointer type, the resulting pointer, called a null pointer, is guaranteed to compare unequal to a pointer to any object or function.
And note 55 says:
55) The macro NULL is defined in
<stddef.h>
(and other headers) as a null pointer constant.
Notice that, because of how the rules for null pointers are formulated, the value you use to assign/compare null pointers is guaranteed to be zero, but the bit pattern actually stored inside the pointer can be any other thing (but AFAIK only few very esoteric platforms exploited this fact, and this should not be a problem anyway since to "see" the underlying bit pattern you should go into UB-land anyway).
So, as far as the standard is concerned, the two forms are equivalent (!ptr
is equivalent to ptr==0
due to §6.5.3.3 ¶5, and ptr==0
is equivalent to ptr==NULL
); if(!ptr)
is also quite idiomatic.
That being said, I usually write explicitly if(ptr==NULL)
instead of if(!ptr)
to make it extra clear that I'm checking a pointer for nullity instead of some boolean value.
void *
cast cannot be present due to the stricter implicit casting rules that would make the usage of such NULL
cumbersome (you would have to explicitly convert it to the compared pointer's type every time).From the language standard:
6.3.2.3 Pointers
...
3 An integer constant expression with the value 0, or such an expression cast to typevoid *
, is called a null pointer constant.55) If a null pointer constant is converted to a pointer type, the resulting pointer, called a null pointer, is guaranteed to compare unequal to a pointer to any object or function.
...
55) The macroNULL
is defined in<stddef.h>
(and other headers) as a null pointer constant; see 7.17.
Given that language, the macro NULL should evaluate to a zero-valued expression (either an undecorated literal 0
, an expression like (void *) 0
, or another macro or expression that ultimately evaluates to 0). The expressions ptr == NULL
and !ptr
should be equivalent. The second form tends to be more idiomatic C code.
Note that the null pointer value doesn't have to be 0. The underlying implementation may use any value it wants to represent a null pointer. As far as your source code is concerned, however, a zero-valued pointer expression represents a null pointer.
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With