When to use null and when to use static_cast<som e_pointer_type> (0)?

[PengYu.UT]

I see some code use static_cast<som e_pointer_type> (0) instead of NULL
to describe null pointer. I'm wondering what is the pros and cons of
each way. Is there any reason why we should one verses the other.

[Phlip]

Pe*******@gmail .com wrote:

I see some code use static_cast<som e_pointer_type> (0) instead of NULL
to describe null pointer. I'm wondering what is the pros and cons of
each way. Is there any reason why we should one verses the other.

What code does it the complex way? Could you post a sample?

NULL is magic, and should generally always appear as the constant "NULL".
Maybe you saw code that upgraded from C, which used (void*)0.

NULL is magic because a constant 0, in C++, always freely converts to any
pointer type, just as typesafely as if you had put an elaborate cast on it.
Don't.

--
Phlip
http://www.greencheese.org/ZeekLand <-- NOT a blog!!!

[PengYu.UT]

Phlip wrote:

Pe*******@gmail .com wrote:

I see some code use static_cast<som e_pointer_type> (0) instead of NULL
to describe null pointer. I'm wondering what is the pros and cons of
each way. Is there any reason why we should one verses the other.
What code does it the complex way? Could you post a sample?

template <class T>
class Nil {
public:
operator T* () { return static_cast<T*> (0); }
};

template <class T>
void Delete(T*& x) {
delete x;
x = Nil<T>();
}

The above is the code fragment.

In general, NULL is preferred, right?

NULL is magic, and should generally always appear as the constant "NULL".
Maybe you saw code that upgraded from C, which used (void*)0.

NULL is magic because a constant 0, in C++, always freely converts to any
pointer type, just as typesafely as if you had put an elaborate cast on it.
Don't.

--
Phlip
http://www.greencheese.org/ZeekLand <-- NOT a blog!!!

[Noah Roberts]

Pe*******@gmail .com wrote:

Phlip wrote:

Pe*******@gmail .com wrote:

I see some code use static_cast<som e_pointer_type> (0) instead of NULL
to describe null pointer. I'm wondering what is the pros and cons of
each way. Is there any reason why we should one verses the other.

What code does it the complex way? Could you post a sample?

template <class T>
class Nil {
public:
operator T* () { return static_cast<T*> (0); }

That cast is invalid and, luckily, unnecissary.

You can't static_cast between unrelated types. An int and a T* are
totally unrelated. Luckily enough, 0 is magic in that it can be any
pointer as well as an integral. So, that is just calling a static cast
from T* to T*...if it wasn't the code would not compile.

What the original coder probably intended was a reinterpret cast.
However, since the static cast worked it shows that it is not necissary
to perform any casting at all.

[Alf P. Steinbach]

* Noah Roberts wrote, on 31/03/2006 22:53:

Pe*******@gmail .com wrote:

template <class T>
class Nil {
public:
operator T* () { return static_cast<T*> (0); }
That cast is invalid

No.

and, luckily, unnecissary.
Yes.
[snip] What the original coder probably intended was a reinterpret cast.

No, that would be invalid. ;-)
--
A: Because it messes up the order in which people normally read text.
Q: Why is it such a bad thing?
A: Top-posting.
Q: What is the most annoying thing on usenet and in e-mail?

[Phlip]

Noah Roberts wrote:

template <class T>
class Nil {
public:
operator T* () { return static_cast<T*> (0); }

That cast is invalid and, luckily, unnecissary.

I want to know why the Nil class is there. If its only purpose is this line

delete x;
x = Nil<T>();

then it is an excessive and unnecessary way to write x = NULL.

Someone may have Template Fever here. ;-)

--
Phlip
http://www.greencheese.org/ZeekLand <-- NOT a blog!!!

[Pete Becker]

Phlip wrote:

Someone may have Template Fever here. ;-)

Unfortunately, a far too common ailment.

--

Pete Becker
Roundhouse Consulting, Ltd.

[Michiel.Salters]

Pe*******@gmail .com wrote:

I see some code use static_cast<som e_pointer_type> (0) instead of NULL
to describe null pointer. I'm wondering what is the pros and cons of
each way. Is there any reason why we should one verses the other.

Consider:

MyStream& operator<<(MySt ream&, int);
MyStream& operator<<(MySt ream&, const char*);

MyStream m;
m << NULL;
m << static_cast<cha r*>(0);

HTH
Michiel Salters

[Noah Roberts]

Alf P. Steinbach wrote:

* Noah Roberts wrote, on 31/03/2006 22:53:

Pe*******@gmail .com wrote:

template <class T>
class Nil {
public:
operator T* () { return static_cast<T*> (0); }

That cast is invalid

No.

and, luckily, unnecissary.

Yes.
[snip]

What the original coder probably intended was a reinterpret cast.

No, that would be invalid. ;-)

Interesting. How do you figure? Since 0 is an int (except when used
as a pointer, which such added behavior is what renders any cast moot)
I can't think of any static_cast that is valid. In fact g++ pukes when
you try to static_cast but allows the reinterpret_cas t through just
fine.

int main()
{
int x = 0;
int *r = reinterpret_cas t<int*>(x);
int *p = static_cast<int *>(x);

return 0;
}

g++ stat.cpp
stat.cpp: In function `int main()':
stat.cpp:5: error: invalid static_cast from type `int' to type `int*'
g++ seems to think it is an invalid cast. So do I.

[Thomas Tutone]

The OP wrote:

> operator T* () { return static_cast<T*> (0); }
Noah Roberts wrote:
That cast is invalid

Alf P. Steinbach wrote:

No.
Noah Roberts:
What the original coder probably intended was a reinterpret cast.

Alf Steinbach:
No, that would be invalid. ;-)

Noah Roberts:
Interesting. How do you figure? Since 0 is an int (except when used
as a pointer, which such added behavior is what renders any cast moot)
You're starting from a flawed premise - or rather, your exception
swallows the rule.
I can't think of any static_cast that is valid. In fact g++ pukes when
you try to static_cast but allows the reinterpret_cas t through just
fine.

int main()
{
int x = 0;
int *r = reinterpret_cas t<int*>(x);
int *p = static_cast<int *>(x);

return 0;
}

Yes, but the following compiles fine:

int main()
{
int *r = reinterpret_cas t<int*>(0);
int *p = static_cast<int *>(0);
}

What started out this subthread was your assertion that
static_cast<T*> (0) is an invalid cast. Alf Steinbach said it was
valid. He's right. In response you said that static_cast<T*> (i) was
an invalid cast where i==0. That's true, but different from your
original assertion.

Best regards,

Tom