CODEWITHSUNDEEP
c++null
Aykhan Hagverdili
Aykhan Hagverdili

Reputation: 29975

Is NULL guaranteed to be 0?

I was wondering if NULL is guaranteed to be 0 in C++, so I searched and came across these:

This answer states that:

Here is Bjarne Stroustrup's wordings,

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 with NULL is that people sometimes mistakenly believe that it is different from 0 and/or not an integer.

Which seems to confirm that NULL is always 0.

But according to cppreference.com: 

#define NULL /*implementation-defined*/

The macro NULL is an implementation-defined null pointer constant, which may be:

-> an integral constant expression rvalue of integer type that evaluates to zero (until C++11)

-> an integer literal with value zero, or a prvalue of type std::nullptr_t (since C++11)

And that clearly says NULL is implementation dependent.

This answer says:

0 (aka. C's NULL bridged over into C++) could cause ambiguity in overloaded function resolution, among other things:

f(int); 
f(foo *);

Which again implies that NULL is the integer 0 and that might cause ambiguity

There are other questions and answers I encountered, but they are mostly about the C language, not C++. This comment says:

And NULL is guaranteed to be 0

But again, that's about C.

To sum it all up, is NULL always 0 in C++? What about C? Is it (for every standard implementation) the same as:

#define NULL 0

Note: this question is not about the null pointer, the question is if NULL in C++ is guaranteed to be 0 the integer. Is it implementation dependent?

Upvotes: 10

Views: 2018

Answers (2)

eerorika
eerorika

Reputation: 238351

Is NULL guaranteed to be 0?

According to the standard, NULL is a null pointer constant (i.e. literal). Exactly which one, is implementation defined.

Prior to C++11, null pointer constants were integral constants whose integral value is equal to 0, so 0 or 0l etc.

Since C++11, there is a new null pointer literal nullptr and NULL may be defined as being nullptr. (And thus literal interpretation of Bjarne's quote has become obsolete).

Prior to standardisation: NULL may be defined as (void*)0 in C. Since C++ was based on C, it is likely that some C++ dialects pre-dating the standard might have used that definition, but such definition is not conformant with standard C++.

And for completeness: As explained in more detail in SO post linked in a comment below, null pointer constant being 0 does not necessarily mean that the value of the null pointer address is 0 (although the address being 0 is quite typical).

What can be concluded about this:

  • Don't use NULL to represent the number zero (use 0 with appropriate type suffix if appropriate), nor to represent a null-terminator character (use '\0').
  • Don't assume that NULL resolves to a pointer overload.
  • To represent a null pointer, don't use NULL but instead use nullptr if your standard is >= C++11. In older standard you can use (T*)NULL or (T*)0 if you need it for overload resolution... that said there are probably very few cases where overloading integers with pointers makes any sense.
  • Consider that the definition may differ when converting from C to C++ and vice versa.
  • Don't memset (or type pun) zero bits into a pointer. That's not guaranteed to be the null pointer.

Upvotes: 9

Mike
Mike

Reputation: 302

I think its fine practice to assume so. Having said that, it would be horrible practice to #undef NULL and or redefine it as something else. So long story short, it's not a 100% guarentee because it is possible to be something else, but it NEVER should be.

Upvotes: 0

Related Questions