NULL vs. 0

[red floyd]

I searched the FAQ on this one, couldn't really find an answer.

Stylistically, is it better to use 0 or NULL?

I know that pre-Standard, 0 was recommended, because some compilers
implemented NULL improperly.

However, 18.1/4(footnote 180) indicates that 0 and 0L are valid NULLs,
while (void*)0 is explicitly invalid.

So, assuming a (reasonably) Standard compliant compiler, is there a
reason to continue to prefer 0 over NULL? NULL would seem to have the
advantage of indicating that we're checking a pointer.

Also, did nullptr make it into the C++0x draft?

[Julián Albo]

Roy Smith wrote:

Also, I can easily search for the string NULL in my source code. You
don't realize how important stuff like that is until you've got a million
lines of source code to slog trough trying to find constructs which might
tickle some new compiler bug that was just discovered.

You can use something like:

template <class T> T * NullPtr () { return static_cast <T *> (0); }
template <class T> bool isNull (T * ptr) { return ptr == 0; }

That way you have easy searchability and type safety for a low price.

--
Salu2

Inviato da X-Privat.Org - Registrazione gratuita http://www.x-privat.org/join.php

[gottlobfrege]

red floyd wrote:

Andrey Tarasevich wrote:

red floyd wrote:

...
So, assuming a (reasonably) Standard compliant compiler, is there a
reason to continue to prefer 0 over NULL? NULL would seem to have the
advantage of indicating that we're checking a pointer.
...
For that very reason it makes sense to prefer NULL over 0 in pointer context.
Otherwise, they are equivalent (in such contexts).

Thanks Alf and Andrey. As I said, the 0 habit was from pre-Standard
days, based on old versions of TCPPPL (1st and 2nd editions!!!).

Just curious about prevailing style.

The prevailing style is that it is a religious debate similar to where
you put your brackets, only the case of null, the standard is working
on resolving the debate.

Thanks again!

[Phlip]

Rolf Magnus wrote:

Use NULL to state your intent as clearly and prouncably as possible.

That's self-contradictory. NULL is an integer, but one usually thinks of
it
as a pointer, because it is only used in pointer context. So using NULL to
hide the fact that you have an integer is less clear than directly using
0.

http://groups.google.com/groups/search?q=kanze+null

If you think you have a stand here, you owe Kanze a post. ;-)

--
Phlip
http://c2.com/cgi/wiki?ZeekLand <-- NOT a blog!!!

[Phlip]

Julián Albo wrote:

You can use something like:

template <class T> T * NullPtr () { return static_cast <T *> (0); }
template <class T> bool isNull (T * ptr) { return ptr == 0; }

You have two typographical errors there. Allow me to fix them:

.... urn static_cast <T *> (NULL); }
.... tr) { return ptr == NULL; }

Aah, much more readable and pronouncable.

--
Phlip
http://c2.com/cgi/wiki?ZeekLand <-- NOT a blog!!!

[Phlip]

gottlobfrege wrote:

The prevailing style is that it is a religious debate similar to where
you put your brackets, only the case of null, the standard is working
on resolving the debate.

Part of learning C++ is learning which style issues are really technical
issues. {} is style. NULL is technical.

--
Phlip
http://c2.com/cgi/wiki?ZeekLand <-- NOT a blog!!!

[Noah Roberts]

Alf P. Steinbach wrote:

* red floyd:

Footnote
180 to 18.1/4 specifically disallows (void*)0, is there any good modern
reason to use 0 instead of NULL anymore?

NULL generally indicates (to the human reader) a pointer value, in about
the same way that struct indicates (to the human reader) a POD.

A rather disagree that struct indicates POD. It is an artificial
indicator at best, one easily broken as the language makes no such
distinction. I don't think this is something that can be depended on
at all and therefore is no indicator that we have a POD vs. non-POD.

[Julián Albo]

Phlip wrote:

You can use something like:

template <class T> T * NullPtr () { return static_cast <T *> (0); }
template <class T> bool isNull (T * ptr) { return ptr == 0; }

You have two typographical errors there. Allow me to fix them:

... urn static_cast <T *> (NULL); }
... tr) { return ptr == NULL; }

Aah, much more readable and pronouncable.

We can make another enhancement:

template <class T> bool isNull (T * ptr) { return isNull (ptr); }

Much more readable this way X-)

--
Salu2

Inviato da X-Privat.Org - Registrazione gratuita http://www.x-privat.org/join.php

[Richard Herring]

In message <Nt************ *******@newssvr 11.news.prodigy .com>, Phlip
<ph******@yahoo .com> writes

Julián Albo wrote:

You can use something like:

template <class T> T * NullPtr () { return static_cast <T *> (0); }
template <class T> bool isNull (T * ptr) { return ptr == 0; }
You have two typographical errors there. Allow me to fix them:

... urn static_cast <T *> (NULL); }
... tr) { return ptr == NULL; }

And now to get the definition of NULL you have to #include some huge
header file in something which is itself going to be included all over
the place.
Aah, much more readable and pronouncable.

Who wants to do either?

--
Richard Herring

[SuperKoko]

go**********@gm ail.com wrote:

red floyd wrote:

2. I have, and have read TC++PL3e. My point was that because the
Standard 18.1/4 specifies "The macro NULL is an implementation-defined
null pointer constant in this International Standard (4.10)." Footnote
180 to 18.1/4 specifically disallows (void*)0, is there any good modern
reason to use 0 instead of NULL anymore?
You are asking why someone would *still* use 0 instead of NULL, as if
NULL was somehow better (ie maybe more descriptive).

I would rather ask why someone would *still* use NULL instead of 0?
NULL is a macro, 0 is what you are really saying - why hide that with
an unnecessary macro?

There are several good reasons.
The best one : It is more human-friendly... You know the intent of the
programmer (assuming that the programmer uses NULL in pointer contexts
only).
But there are other reasons.
For instance, with Borland C++ 5.0 (for x86 CPU), in 16 bits real mode,
the definition of NULL depends on the memory model.
For memory models where pointers are 16 bits large (tiny, small,
medium), NULL is 0 (and int are 16 bits)
For memory models where pointers are 32 bits (compact, large, huge),
NULL is 0L (and long are 32 bits)
On this platform, the representation for the NULL pointer is
all-bits-zero, which is the same representation than the 0 integer
constant (both signed and unsigned).
Using NULL, can avoid bad behaviors in UB contexts.
For instance:
printf("%p", NULL); /* Undefined behavior : But works "as expected"
with Borland C++ */

P.S. macros are evil.

Even if the standard says that NULL is a macro, it can be a "harmless"
macro.
i.e., it can be implemented as:

/* dummy macro definition */
#define NULL NULL
const int NULL=0;
I would like to say that the fact that NULL is not type safe in C++
doesn't mean that it must not be used... Even if the compiler doesn't
make any difference between NULL and 0, programmers do.

I can think of very very old implementations of C, where "char*" and
"int" appeared to be almost semantically equivalent (because the
compiler did very very bad type checking, and dereferencing int was
"accepted" by the compiler).
But, it would be a very bad idea to use one type for the other.

[Sgt. York]

Phlip wrote:

Julián Albo wrote:

You can use something like:

template <class T> T * NullPtr () { return static_cast <T *> (0); }
template <class T> bool isNull (T * ptr) { return ptr == 0; }

You have two typographical errors there. Allow me to fix them:

... urn static_cast <T *> (NULL); }
... tr) { return ptr == NULL; }

Aah, much more readable and pronouncable.

Chutzpah, man! You make a great point here. The hairs remain unsplit.