In the early days of C++ when it was bolted on top of C, you could not use NULL as it was defined as (void*)0
. You could not assign NULL to any pointer other than void*
, which made it kind of useless. Back in those days, it was accepted that you used 0
(zero) for null pointers.
To this day, I have continued to use zero as a null pointer but those around me insist on using NULL
. I personally do not see any benefit to giving a name (NULL
) to an existing value - and since I also like to test pointers as truth values:
if (p && !q)
do_something();
then using zero makes more sense (as in if you use NULL
, you cannot logically use p && !q
- you need to explicitly compare against NULL
, unless you assume NULL
is zero, in which case why use NULL
).
Is there any objective reason to prefer zero over NULL (or vice versa), or is all just personal preference?
Edit: I should add (and meant to originally say) that with RAII and exceptions, I rarely use zero/NULL pointers, but sometimes you do need them still.
Here's Stroustrup's take on this: C++ Style and Technique FAQ
In C++, the definition of
NULL
is 0, so there is only an aesthetic difference. I prefer to avoid macros, so I use 0. Another problem withNULL
is that people sometimes mistakenly believe that it is different from 0 and/or not an integer. In pre-standard code,NULL
was/is sometimes defined to something unsuitable and therefore had/has to be avoided. That's less common these days.If you have to name the null pointer, call it
nullptr
; that's what it's called in C++11. Then,nullptr
will be a keyword.
That said, don't sweat the small stuff.
There are a few arguments (one of which is relatively recent) which I believe contradict Bjarne's position on this.
Using NULL
allows for searches on it's use and it also highlights that the developer wanted to use a NULL
pointer, irrespective of whether it is being interpreted by the compiler as NULL
or not.
The example that everybody quotes is:
void foo(int*);
void foo (int);
void bar() {
foo (NULL); // Calls 'foo(int)'
}
However, at least in my opinion, the problem with the above is not that we're using NULL for the null pointer constant, it's that we have overloads of 'foo' which take very different kinds of arguments. The parameter must be an int
too, as any other type will result in an ambiguous call and so generate a helpful compiler warning.
Even in the absence of C++ 0x, there are tools available today that verify that NULL
is being used for pointers, and that 0
is being used for integral types.
std::nullptr_t
type.This is the newest argument to the table. The problem of 0
and NULL
is being actively addressed for C++ 0x, and you can guarantee that for every implementation that provides NULL
, the very first thing that they will do is:
#define NULL nullptr
For those who use NULL
rather than 0
, the change will be an improvement in type-safety with little or no effort - if anything it may also catch a few bugs where they've used NULL
for 0
. For anybody using 0
today....erm...well hopefully they have a good knowledge of regular expressions...