How do we check if a pointer is NULL pointer?
I always think simply if(p != NULL){..} will do the job. But after reading this Stack Overflow question, it seems not.
So what's the canonical way to check for NULL pointers after absorbing all discussion in that question which says NULL pointers can have non-zero value?
Solution 1:
I always think simply if(p != NULL){..} will do the job.
It will.
Solution 2:
First, to be 100% clear, there is no difference between C and C++ here. And second, the Stack Overflow question you cite doesn't talk about null pointers; it introduces invalid pointers; pointers which, at least as far as the standard is concerned, cause undefined behavior just by trying to compare them. There is no way to test in general whether a pointer is valid.
In the end, there are three widespread ways to check for a null pointer:
if ( p != NULL ) ...
if ( p != 0 ) ...
if ( p ) ...
All work, regardless of the representation of a null pointer on the
machine. And all, in some way or another, are misleading; which one you
choose is a question of choosing the least bad. Formally, the first two
are indentical for the compiler; the constant NULL or 0 is converted
to a null pointer of the type of p, and the results of the conversion
are compared to p. Regardless of the representation of a null
pointer.
The third is slightly different: p is implicitly converted
to bool. But the implicit conversion is defined as the results of p
!= 0, so you end up with the same thing. (Which means that there's
really no valid argument for using the third style—it obfuscates
with an implicit conversion, without any offsetting benefit.)
Which one of the first two you prefer is largely a matter of style,
perhaps partially dictated by your programming style elsewhere:
depending on the idiom involved, one of the lies will be more bothersome
than the other. If it were only a question of comparison, I think most
people would favor NULL, but in something like f( NULL ), the
overload which will be chosen is f( int ), and not an overload with a
pointer. Similarly, if f is a function template, f( NULL ) will
instantiate the template on int. (Of course, some compilers, like
g++, will generate a warning if NULL is used in a non-pointer context;
if you use g++, you really should use NULL.)
In C++11, of course, the preferred idiom is:
if ( p != nullptr ) ...
, which avoids most of the problems with the other solutions. (But it is not C-compatible:-).)
Solution 3:
The compiler must provide a consistent type system, and provide a set of standard conversions. Neither the integer value 0 nor the NULL pointer need to be represented by all-zero bits, but the compiler must take care of converting the "0" token in the input file to the correct representation for integer zero, and the cast to pointer type must convert from integer to pointer representation.
The implication of this is that
void *p;
memset(&p, 0, sizeof p);
if(p) { ... }
is not guaranteed to behave the same on all target systems, as you are making an assumption about the bit pattern here.
As an example, I have an embedded platform that has no memory protection, and keeps the interrupt vectors at address 0, so by convention, integers and pointers are XORed with 0x2000000 when converted, which leaves (void *)0 pointing at an address that generates a bus error when dereferenced, however testing the pointer with an if statement will return it to integer representation first, which is then all-zeros.
Solution 4:
The actual representation of a null pointer is irrelevant here. An integer literal with value zero (including 0 and any valid definition of NULL) can be converted to any pointer type, giving a null pointer, whatever the actual representation. So p != NULL, p != 0 and p are all valid tests for a non-null pointer.
You might run into problems with non-zero representations of the null pointer if you wrote something twisted like p != reinterpret_cast<void*>(0), so don't do that.
Although I've just noticed that your question is tagged C as well as C++. My answer refers to C++, and other languages may be different. Which language are you using?
Solution 5:
Apparently the thread you refer is about C++.
In C your snippet will always work. I like the simpler if (p) { /* ... */ }.